1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2018 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
32 #include "dwarf2read.h"
33 #include "dwarf-index-common.h"
42 #include "gdb-demangle.h"
43 #include "expression.h"
44 #include "filenames.h" /* for DOSish file names */
47 #include "complaints.h"
49 #include "dwarf2expr.h"
50 #include "dwarf2loc.h"
51 #include "cp-support.h"
57 #include "typeprint.h"
60 #include "completer.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
71 #include "filestuff.h"
73 #include "namespace.h"
74 #include "common/gdb_unlinker.h"
75 #include "common/function-view.h"
76 #include "common/gdb_optional.h"
77 #include "common/underlying.h"
78 #include "common/byte-vector.h"
79 #include "common/hash_enum.h"
80 #include "filename-seen-cache.h"
83 #include <sys/types.h>
85 #include <unordered_set>
86 #include <unordered_map>
90 #include <forward_list>
91 #include "rust-lang.h"
92 #include "common/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_data *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 /* The name_component table (a sorted vector). See name_component's
151 description above. */
152 std::vector<name_component> name_components;
154 /* How NAME_COMPONENTS is sorted. */
155 enum case_sensitivity name_components_casing;
157 /* Return the number of names in the symbol table. */
158 virtual size_t symbol_name_count () const = 0;
160 /* Get the name of the symbol at IDX in the symbol table. */
161 virtual const char *symbol_name_at (offset_type idx) const = 0;
163 /* Return whether the name at IDX in the symbol table should be
165 virtual bool symbol_name_slot_invalid (offset_type idx) const
170 /* Build the symbol name component sorted vector, if we haven't
172 void build_name_components ();
174 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
175 possible matches for LN_NO_PARAMS in the name component
177 std::pair<std::vector<name_component>::const_iterator,
178 std::vector<name_component>::const_iterator>
179 find_name_components_bounds (const lookup_name_info &ln_no_params) const;
181 /* Prevent deleting/destroying via a base class pointer. */
183 ~mapped_index_base() = default;
186 /* A description of the mapped index. The file format is described in
187 a comment by the code that writes the index. */
188 struct mapped_index final : public mapped_index_base
190 /* A slot/bucket in the symbol table hash. */
191 struct symbol_table_slot
193 const offset_type name;
194 const offset_type vec;
197 /* Index data format version. */
200 /* The address table data. */
201 gdb::array_view<const gdb_byte> address_table;
203 /* The symbol table, implemented as a hash table. */
204 gdb::array_view<symbol_table_slot> symbol_table;
206 /* A pointer to the constant pool. */
207 const char *constant_pool = nullptr;
209 bool symbol_name_slot_invalid (offset_type idx) const override
211 const auto &bucket = this->symbol_table[idx];
212 return bucket.name == 0 && bucket.vec;
215 /* Convenience method to get at the name of the symbol at IDX in the
217 const char *symbol_name_at (offset_type idx) const override
218 { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
220 size_t symbol_name_count () const override
221 { return this->symbol_table.size (); }
224 /* A description of the mapped .debug_names.
225 Uninitialized map has CU_COUNT 0. */
226 struct mapped_debug_names final : public mapped_index_base
228 mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
229 : dwarf2_per_objfile (dwarf2_per_objfile_)
232 struct dwarf2_per_objfile *dwarf2_per_objfile;
233 bfd_endian dwarf5_byte_order;
234 bool dwarf5_is_dwarf64;
235 bool augmentation_is_gdb;
237 uint32_t cu_count = 0;
238 uint32_t tu_count, bucket_count, name_count;
239 const gdb_byte *cu_table_reordered, *tu_table_reordered;
240 const uint32_t *bucket_table_reordered, *hash_table_reordered;
241 const gdb_byte *name_table_string_offs_reordered;
242 const gdb_byte *name_table_entry_offs_reordered;
243 const gdb_byte *entry_pool;
250 /* Attribute name DW_IDX_*. */
253 /* Attribute form DW_FORM_*. */
256 /* Value if FORM is DW_FORM_implicit_const. */
257 LONGEST implicit_const;
259 std::vector<attr> attr_vec;
262 std::unordered_map<ULONGEST, index_val> abbrev_map;
264 const char *namei_to_name (uint32_t namei) const;
266 /* Implementation of the mapped_index_base virtual interface, for
267 the name_components cache. */
269 const char *symbol_name_at (offset_type idx) const override
270 { return namei_to_name (idx); }
272 size_t symbol_name_count () const override
273 { return this->name_count; }
276 /* See dwarf2read.h. */
279 get_dwarf2_per_objfile (struct objfile *objfile)
281 return ((struct dwarf2_per_objfile *)
282 objfile_data (objfile, dwarf2_objfile_data_key));
285 /* Set the dwarf2_per_objfile associated to OBJFILE. */
288 set_dwarf2_per_objfile (struct objfile *objfile,
289 struct dwarf2_per_objfile *dwarf2_per_objfile)
291 gdb_assert (get_dwarf2_per_objfile (objfile) == NULL);
292 set_objfile_data (objfile, dwarf2_objfile_data_key, dwarf2_per_objfile);
295 /* Default names of the debugging sections. */
297 /* Note that if the debugging section has been compressed, it might
298 have a name like .zdebug_info. */
300 static const struct dwarf2_debug_sections dwarf2_elf_names =
302 { ".debug_info", ".zdebug_info" },
303 { ".debug_abbrev", ".zdebug_abbrev" },
304 { ".debug_line", ".zdebug_line" },
305 { ".debug_loc", ".zdebug_loc" },
306 { ".debug_loclists", ".zdebug_loclists" },
307 { ".debug_macinfo", ".zdebug_macinfo" },
308 { ".debug_macro", ".zdebug_macro" },
309 { ".debug_str", ".zdebug_str" },
310 { ".debug_line_str", ".zdebug_line_str" },
311 { ".debug_ranges", ".zdebug_ranges" },
312 { ".debug_rnglists", ".zdebug_rnglists" },
313 { ".debug_types", ".zdebug_types" },
314 { ".debug_addr", ".zdebug_addr" },
315 { ".debug_frame", ".zdebug_frame" },
316 { ".eh_frame", NULL },
317 { ".gdb_index", ".zgdb_index" },
318 { ".debug_names", ".zdebug_names" },
319 { ".debug_aranges", ".zdebug_aranges" },
323 /* List of DWO/DWP sections. */
325 static const struct dwop_section_names
327 struct dwarf2_section_names abbrev_dwo;
328 struct dwarf2_section_names info_dwo;
329 struct dwarf2_section_names line_dwo;
330 struct dwarf2_section_names loc_dwo;
331 struct dwarf2_section_names loclists_dwo;
332 struct dwarf2_section_names macinfo_dwo;
333 struct dwarf2_section_names macro_dwo;
334 struct dwarf2_section_names str_dwo;
335 struct dwarf2_section_names str_offsets_dwo;
336 struct dwarf2_section_names types_dwo;
337 struct dwarf2_section_names cu_index;
338 struct dwarf2_section_names tu_index;
342 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
343 { ".debug_info.dwo", ".zdebug_info.dwo" },
344 { ".debug_line.dwo", ".zdebug_line.dwo" },
345 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
346 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
347 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
348 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
349 { ".debug_str.dwo", ".zdebug_str.dwo" },
350 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
351 { ".debug_types.dwo", ".zdebug_types.dwo" },
352 { ".debug_cu_index", ".zdebug_cu_index" },
353 { ".debug_tu_index", ".zdebug_tu_index" },
356 /* local data types */
358 /* The data in a compilation unit header, after target2host
359 translation, looks like this. */
360 struct comp_unit_head
364 unsigned char addr_size;
365 unsigned char signed_addr_p;
366 sect_offset abbrev_sect_off;
368 /* Size of file offsets; either 4 or 8. */
369 unsigned int offset_size;
371 /* Size of the length field; either 4 or 12. */
372 unsigned int initial_length_size;
374 enum dwarf_unit_type unit_type;
376 /* Offset to the first byte of this compilation unit header in the
377 .debug_info section, for resolving relative reference dies. */
378 sect_offset sect_off;
380 /* Offset to first die in this cu from the start of the cu.
381 This will be the first byte following the compilation unit header. */
382 cu_offset first_die_cu_offset;
384 /* 64-bit signature of this type unit - it is valid only for
385 UNIT_TYPE DW_UT_type. */
388 /* For types, offset in the type's DIE of the type defined by this TU. */
389 cu_offset type_cu_offset_in_tu;
392 /* Type used for delaying computation of method physnames.
393 See comments for compute_delayed_physnames. */
394 struct delayed_method_info
396 /* The type to which the method is attached, i.e., its parent class. */
399 /* The index of the method in the type's function fieldlists. */
402 /* The index of the method in the fieldlist. */
405 /* The name of the DIE. */
408 /* The DIE associated with this method. */
409 struct die_info *die;
412 /* Internal state when decoding a particular compilation unit. */
415 explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
418 DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
420 /* The header of the compilation unit. */
421 struct comp_unit_head header {};
423 /* Base address of this compilation unit. */
424 CORE_ADDR base_address = 0;
426 /* Non-zero if base_address has been set. */
429 /* The language we are debugging. */
430 enum language language = language_unknown;
431 const struct language_defn *language_defn = nullptr;
433 const char *producer = nullptr;
435 /* The generic symbol table building routines have separate lists for
436 file scope symbols and all all other scopes (local scopes). So
437 we need to select the right one to pass to add_symbol_to_list().
438 We do it by keeping a pointer to the correct list in list_in_scope.
440 FIXME: The original dwarf code just treated the file scope as the
441 first local scope, and all other local scopes as nested local
442 scopes, and worked fine. Check to see if we really need to
443 distinguish these in buildsym.c. */
444 struct pending **list_in_scope = nullptr;
446 /* Hash table holding all the loaded partial DIEs
447 with partial_die->offset.SECT_OFF as hash. */
448 htab_t partial_dies = nullptr;
450 /* Storage for things with the same lifetime as this read-in compilation
451 unit, including partial DIEs. */
452 auto_obstack comp_unit_obstack;
454 /* When multiple dwarf2_cu structures are living in memory, this field
455 chains them all together, so that they can be released efficiently.
456 We will probably also want a generation counter so that most-recently-used
457 compilation units are cached... */
458 struct dwarf2_per_cu_data *read_in_chain = nullptr;
460 /* Backlink to our per_cu entry. */
461 struct dwarf2_per_cu_data *per_cu;
463 /* How many compilation units ago was this CU last referenced? */
466 /* A hash table of DIE cu_offset for following references with
467 die_info->offset.sect_off as hash. */
468 htab_t die_hash = nullptr;
470 /* Full DIEs if read in. */
471 struct die_info *dies = nullptr;
473 /* A set of pointers to dwarf2_per_cu_data objects for compilation
474 units referenced by this one. Only set during full symbol processing;
475 partial symbol tables do not have dependencies. */
476 htab_t dependencies = nullptr;
478 /* Header data from the line table, during full symbol processing. */
479 struct line_header *line_header = nullptr;
480 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
481 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
482 this is the DW_TAG_compile_unit die for this CU. We'll hold on
483 to the line header as long as this DIE is being processed. See
484 process_die_scope. */
485 die_info *line_header_die_owner = nullptr;
487 /* A list of methods which need to have physnames computed
488 after all type information has been read. */
489 std::vector<delayed_method_info> method_list;
491 /* To be copied to symtab->call_site_htab. */
492 htab_t call_site_htab = nullptr;
494 /* Non-NULL if this CU came from a DWO file.
495 There is an invariant here that is important to remember:
496 Except for attributes copied from the top level DIE in the "main"
497 (or "stub") file in preparation for reading the DWO file
498 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
499 Either there isn't a DWO file (in which case this is NULL and the point
500 is moot), or there is and either we're not going to read it (in which
501 case this is NULL) or there is and we are reading it (in which case this
503 struct dwo_unit *dwo_unit = nullptr;
505 /* The DW_AT_addr_base attribute if present, zero otherwise
506 (zero is a valid value though).
507 Note this value comes from the Fission stub CU/TU's DIE. */
508 ULONGEST addr_base = 0;
510 /* The DW_AT_ranges_base attribute if present, zero otherwise
511 (zero is a valid value though).
512 Note this value comes from the Fission stub CU/TU's DIE.
513 Also note that the value is zero in the non-DWO case so this value can
514 be used without needing to know whether DWO files are in use or not.
515 N.B. This does not apply to DW_AT_ranges appearing in
516 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
517 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
518 DW_AT_ranges_base *would* have to be applied, and we'd have to care
519 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
520 ULONGEST ranges_base = 0;
522 /* When reading debug info generated by older versions of rustc, we
523 have to rewrite some union types to be struct types with a
524 variant part. This rewriting must be done after the CU is fully
525 read in, because otherwise at the point of rewriting some struct
526 type might not have been fully processed. So, we keep a list of
527 all such types here and process them after expansion. */
528 std::vector<struct type *> rust_unions;
530 /* Mark used when releasing cached dies. */
531 unsigned int mark : 1;
533 /* This CU references .debug_loc. See the symtab->locations_valid field.
534 This test is imperfect as there may exist optimized debug code not using
535 any location list and still facing inlining issues if handled as
536 unoptimized code. For a future better test see GCC PR other/32998. */
537 unsigned int has_loclist : 1;
539 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
540 if all the producer_is_* fields are valid. This information is cached
541 because profiling CU expansion showed excessive time spent in
542 producer_is_gxx_lt_4_6. */
543 unsigned int checked_producer : 1;
544 unsigned int producer_is_gxx_lt_4_6 : 1;
545 unsigned int producer_is_gcc_lt_4_3 : 1;
546 unsigned int producer_is_icc_lt_14 : 1;
548 /* When set, the file that we're processing is known to have
549 debugging info for C++ namespaces. GCC 3.3.x did not produce
550 this information, but later versions do. */
552 unsigned int processing_has_namespace_info : 1;
554 struct partial_die_info *find_partial_die (sect_offset sect_off);
557 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
558 This includes type_unit_group and quick_file_names. */
560 struct stmt_list_hash
562 /* The DWO unit this table is from or NULL if there is none. */
563 struct dwo_unit *dwo_unit;
565 /* Offset in .debug_line or .debug_line.dwo. */
566 sect_offset line_sect_off;
569 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
570 an object of this type. */
572 struct type_unit_group
574 /* dwarf2read.c's main "handle" on a TU symtab.
575 To simplify things we create an artificial CU that "includes" all the
576 type units using this stmt_list so that the rest of the code still has
577 a "per_cu" handle on the symtab.
578 This PER_CU is recognized by having no section. */
579 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
580 struct dwarf2_per_cu_data per_cu;
582 /* The TUs that share this DW_AT_stmt_list entry.
583 This is added to while parsing type units to build partial symtabs,
584 and is deleted afterwards and not used again. */
585 VEC (sig_type_ptr) *tus;
587 /* The compunit symtab.
588 Type units in a group needn't all be defined in the same source file,
589 so we create an essentially anonymous symtab as the compunit symtab. */
590 struct compunit_symtab *compunit_symtab;
592 /* The data used to construct the hash key. */
593 struct stmt_list_hash hash;
595 /* The number of symtabs from the line header.
596 The value here must match line_header.num_file_names. */
597 unsigned int num_symtabs;
599 /* The symbol tables for this TU (obtained from the files listed in
601 WARNING: The order of entries here must match the order of entries
602 in the line header. After the first TU using this type_unit_group, the
603 line header for the subsequent TUs is recreated from this. This is done
604 because we need to use the same symtabs for each TU using the same
605 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
606 there's no guarantee the line header doesn't have duplicate entries. */
607 struct symtab **symtabs;
610 /* These sections are what may appear in a (real or virtual) DWO file. */
614 struct dwarf2_section_info abbrev;
615 struct dwarf2_section_info line;
616 struct dwarf2_section_info loc;
617 struct dwarf2_section_info loclists;
618 struct dwarf2_section_info macinfo;
619 struct dwarf2_section_info macro;
620 struct dwarf2_section_info str;
621 struct dwarf2_section_info str_offsets;
622 /* In the case of a virtual DWO file, these two are unused. */
623 struct dwarf2_section_info info;
624 VEC (dwarf2_section_info_def) *types;
627 /* CUs/TUs in DWP/DWO files. */
631 /* Backlink to the containing struct dwo_file. */
632 struct dwo_file *dwo_file;
634 /* The "id" that distinguishes this CU/TU.
635 .debug_info calls this "dwo_id", .debug_types calls this "signature".
636 Since signatures came first, we stick with it for consistency. */
639 /* The section this CU/TU lives in, in the DWO file. */
640 struct dwarf2_section_info *section;
642 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
643 sect_offset sect_off;
646 /* For types, offset in the type's DIE of the type defined by this TU. */
647 cu_offset type_offset_in_tu;
650 /* include/dwarf2.h defines the DWP section codes.
651 It defines a max value but it doesn't define a min value, which we
652 use for error checking, so provide one. */
654 enum dwp_v2_section_ids
659 /* Data for one DWO file.
661 This includes virtual DWO files (a virtual DWO file is a DWO file as it
662 appears in a DWP file). DWP files don't really have DWO files per se -
663 comdat folding of types "loses" the DWO file they came from, and from
664 a high level view DWP files appear to contain a mass of random types.
665 However, to maintain consistency with the non-DWP case we pretend DWP
666 files contain virtual DWO files, and we assign each TU with one virtual
667 DWO file (generally based on the line and abbrev section offsets -
668 a heuristic that seems to work in practice). */
672 /* The DW_AT_GNU_dwo_name attribute.
673 For virtual DWO files the name is constructed from the section offsets
674 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
675 from related CU+TUs. */
676 const char *dwo_name;
678 /* The DW_AT_comp_dir attribute. */
679 const char *comp_dir;
681 /* The bfd, when the file is open. Otherwise this is NULL.
682 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
685 /* The sections that make up this DWO file.
686 Remember that for virtual DWO files in DWP V2, these are virtual
687 sections (for lack of a better name). */
688 struct dwo_sections sections;
690 /* The CUs in the file.
691 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
692 an extension to handle LLVM's Link Time Optimization output (where
693 multiple source files may be compiled into a single object/dwo pair). */
696 /* Table of TUs in the file.
697 Each element is a struct dwo_unit. */
701 /* These sections are what may appear in a DWP file. */
705 /* These are used by both DWP version 1 and 2. */
706 struct dwarf2_section_info str;
707 struct dwarf2_section_info cu_index;
708 struct dwarf2_section_info tu_index;
710 /* These are only used by DWP version 2 files.
711 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
712 sections are referenced by section number, and are not recorded here.
713 In DWP version 2 there is at most one copy of all these sections, each
714 section being (effectively) comprised of the concatenation of all of the
715 individual sections that exist in the version 1 format.
716 To keep the code simple we treat each of these concatenated pieces as a
717 section itself (a virtual section?). */
718 struct dwarf2_section_info abbrev;
719 struct dwarf2_section_info info;
720 struct dwarf2_section_info line;
721 struct dwarf2_section_info loc;
722 struct dwarf2_section_info macinfo;
723 struct dwarf2_section_info macro;
724 struct dwarf2_section_info str_offsets;
725 struct dwarf2_section_info types;
728 /* These sections are what may appear in a virtual DWO file in DWP version 1.
729 A virtual DWO file is a DWO file as it appears in a DWP file. */
731 struct virtual_v1_dwo_sections
733 struct dwarf2_section_info abbrev;
734 struct dwarf2_section_info line;
735 struct dwarf2_section_info loc;
736 struct dwarf2_section_info macinfo;
737 struct dwarf2_section_info macro;
738 struct dwarf2_section_info str_offsets;
739 /* Each DWP hash table entry records one CU or one TU.
740 That is recorded here, and copied to dwo_unit.section. */
741 struct dwarf2_section_info info_or_types;
744 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
745 In version 2, the sections of the DWO files are concatenated together
746 and stored in one section of that name. Thus each ELF section contains
747 several "virtual" sections. */
749 struct virtual_v2_dwo_sections
751 bfd_size_type abbrev_offset;
752 bfd_size_type abbrev_size;
754 bfd_size_type line_offset;
755 bfd_size_type line_size;
757 bfd_size_type loc_offset;
758 bfd_size_type loc_size;
760 bfd_size_type macinfo_offset;
761 bfd_size_type macinfo_size;
763 bfd_size_type macro_offset;
764 bfd_size_type macro_size;
766 bfd_size_type str_offsets_offset;
767 bfd_size_type str_offsets_size;
769 /* Each DWP hash table entry records one CU or one TU.
770 That is recorded here, and copied to dwo_unit.section. */
771 bfd_size_type info_or_types_offset;
772 bfd_size_type info_or_types_size;
775 /* Contents of DWP hash tables. */
777 struct dwp_hash_table
779 uint32_t version, nr_columns;
780 uint32_t nr_units, nr_slots;
781 const gdb_byte *hash_table, *unit_table;
786 const gdb_byte *indices;
790 /* This is indexed by column number and gives the id of the section
792 #define MAX_NR_V2_DWO_SECTIONS \
793 (1 /* .debug_info or .debug_types */ \
794 + 1 /* .debug_abbrev */ \
795 + 1 /* .debug_line */ \
796 + 1 /* .debug_loc */ \
797 + 1 /* .debug_str_offsets */ \
798 + 1 /* .debug_macro or .debug_macinfo */)
799 int section_ids[MAX_NR_V2_DWO_SECTIONS];
800 const gdb_byte *offsets;
801 const gdb_byte *sizes;
806 /* Data for one DWP file. */
810 dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
812 dbfd (std::move (abfd))
816 /* Name of the file. */
819 /* File format version. */
823 gdb_bfd_ref_ptr dbfd;
825 /* Section info for this file. */
826 struct dwp_sections sections {};
828 /* Table of CUs in the file. */
829 const struct dwp_hash_table *cus = nullptr;
831 /* Table of TUs in the file. */
832 const struct dwp_hash_table *tus = nullptr;
834 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
835 htab_t loaded_cus {};
836 htab_t loaded_tus {};
838 /* Table to map ELF section numbers to their sections.
839 This is only needed for the DWP V1 file format. */
840 unsigned int num_sections = 0;
841 asection **elf_sections = nullptr;
844 /* This represents a '.dwz' file. */
848 dwz_file (gdb_bfd_ref_ptr &&bfd)
849 : dwz_bfd (std::move (bfd))
853 /* A dwz file can only contain a few sections. */
854 struct dwarf2_section_info abbrev {};
855 struct dwarf2_section_info info {};
856 struct dwarf2_section_info str {};
857 struct dwarf2_section_info line {};
858 struct dwarf2_section_info macro {};
859 struct dwarf2_section_info gdb_index {};
860 struct dwarf2_section_info debug_names {};
863 gdb_bfd_ref_ptr dwz_bfd;
866 /* Struct used to pass misc. parameters to read_die_and_children, et
867 al. which are used for both .debug_info and .debug_types dies.
868 All parameters here are unchanging for the life of the call. This
869 struct exists to abstract away the constant parameters of die reading. */
871 struct die_reader_specs
873 /* The bfd of die_section. */
876 /* The CU of the DIE we are parsing. */
877 struct dwarf2_cu *cu;
879 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
880 struct dwo_file *dwo_file;
882 /* The section the die comes from.
883 This is either .debug_info or .debug_types, or the .dwo variants. */
884 struct dwarf2_section_info *die_section;
886 /* die_section->buffer. */
887 const gdb_byte *buffer;
889 /* The end of the buffer. */
890 const gdb_byte *buffer_end;
892 /* The value of the DW_AT_comp_dir attribute. */
893 const char *comp_dir;
895 /* The abbreviation table to use when reading the DIEs. */
896 struct abbrev_table *abbrev_table;
899 /* Type of function passed to init_cutu_and_read_dies, et.al. */
900 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
901 const gdb_byte *info_ptr,
902 struct die_info *comp_unit_die,
906 /* A 1-based directory index. This is a strong typedef to prevent
907 accidentally using a directory index as a 0-based index into an
909 enum class dir_index : unsigned int {};
911 /* Likewise, a 1-based file name index. */
912 enum class file_name_index : unsigned int {};
916 file_entry () = default;
918 file_entry (const char *name_, dir_index d_index_,
919 unsigned int mod_time_, unsigned int length_)
922 mod_time (mod_time_),
926 /* Return the include directory at D_INDEX stored in LH. Returns
927 NULL if D_INDEX is out of bounds. */
928 const char *include_dir (const line_header *lh) const;
930 /* The file name. Note this is an observing pointer. The memory is
931 owned by debug_line_buffer. */
934 /* The directory index (1-based). */
935 dir_index d_index {};
937 unsigned int mod_time {};
939 unsigned int length {};
941 /* True if referenced by the Line Number Program. */
944 /* The associated symbol table, if any. */
945 struct symtab *symtab {};
948 /* The line number information for a compilation unit (found in the
949 .debug_line section) begins with a "statement program header",
950 which contains the following information. */
957 /* Add an entry to the include directory table. */
958 void add_include_dir (const char *include_dir);
960 /* Add an entry to the file name table. */
961 void add_file_name (const char *name, dir_index d_index,
962 unsigned int mod_time, unsigned int length);
964 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
966 const char *include_dir_at (dir_index index) const
968 /* Convert directory index number (1-based) to vector index
970 size_t vec_index = to_underlying (index) - 1;
972 if (vec_index >= include_dirs.size ())
974 return include_dirs[vec_index];
977 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
979 file_entry *file_name_at (file_name_index index)
981 /* Convert file name index number (1-based) to vector index
983 size_t vec_index = to_underlying (index) - 1;
985 if (vec_index >= file_names.size ())
987 return &file_names[vec_index];
990 /* Const version of the above. */
991 const file_entry *file_name_at (unsigned int index) const
993 if (index >= file_names.size ())
995 return &file_names[index];
998 /* Offset of line number information in .debug_line section. */
999 sect_offset sect_off {};
1001 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1002 unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class. */
1004 unsigned int total_length {};
1005 unsigned short version {};
1006 unsigned int header_length {};
1007 unsigned char minimum_instruction_length {};
1008 unsigned char maximum_ops_per_instruction {};
1009 unsigned char default_is_stmt {};
1011 unsigned char line_range {};
1012 unsigned char opcode_base {};
1014 /* standard_opcode_lengths[i] is the number of operands for the
1015 standard opcode whose value is i. This means that
1016 standard_opcode_lengths[0] is unused, and the last meaningful
1017 element is standard_opcode_lengths[opcode_base - 1]. */
1018 std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1020 /* The include_directories table. Note these are observing
1021 pointers. The memory is owned by debug_line_buffer. */
1022 std::vector<const char *> include_dirs;
1024 /* The file_names table. */
1025 std::vector<file_entry> file_names;
1027 /* The start and end of the statement program following this
1028 header. These point into dwarf2_per_objfile->line_buffer. */
1029 const gdb_byte *statement_program_start {}, *statement_program_end {};
1032 typedef std::unique_ptr<line_header> line_header_up;
1035 file_entry::include_dir (const line_header *lh) const
1037 return lh->include_dir_at (d_index);
1040 /* When we construct a partial symbol table entry we only
1041 need this much information. */
1042 struct partial_die_info : public allocate_on_obstack
1044 partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1046 /* Disable assign but still keep copy ctor, which is needed
1047 load_partial_dies. */
1048 partial_die_info& operator=(const partial_die_info& rhs) = delete;
1050 /* Adjust the partial die before generating a symbol for it. This
1051 function may set the is_external flag or change the DIE's
1053 void fixup (struct dwarf2_cu *cu);
1055 /* Read a minimal amount of information into the minimal die
1057 const gdb_byte *read (const struct die_reader_specs *reader,
1058 const struct abbrev_info &abbrev,
1059 const gdb_byte *info_ptr);
1061 /* Offset of this DIE. */
1062 const sect_offset sect_off;
1064 /* DWARF-2 tag for this DIE. */
1065 const ENUM_BITFIELD(dwarf_tag) tag : 16;
1067 /* Assorted flags describing the data found in this DIE. */
1068 const unsigned int has_children : 1;
1070 unsigned int is_external : 1;
1071 unsigned int is_declaration : 1;
1072 unsigned int has_type : 1;
1073 unsigned int has_specification : 1;
1074 unsigned int has_pc_info : 1;
1075 unsigned int may_be_inlined : 1;
1077 /* This DIE has been marked DW_AT_main_subprogram. */
1078 unsigned int main_subprogram : 1;
1080 /* Flag set if the SCOPE field of this structure has been
1082 unsigned int scope_set : 1;
1084 /* Flag set if the DIE has a byte_size attribute. */
1085 unsigned int has_byte_size : 1;
1087 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1088 unsigned int has_const_value : 1;
1090 /* Flag set if any of the DIE's children are template arguments. */
1091 unsigned int has_template_arguments : 1;
1093 /* Flag set if fixup has been called on this die. */
1094 unsigned int fixup_called : 1;
1096 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1097 unsigned int is_dwz : 1;
1099 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1100 unsigned int spec_is_dwz : 1;
1102 /* The name of this DIE. Normally the value of DW_AT_name, but
1103 sometimes a default name for unnamed DIEs. */
1104 const char *name = nullptr;
1106 /* The linkage name, if present. */
1107 const char *linkage_name = nullptr;
1109 /* The scope to prepend to our children. This is generally
1110 allocated on the comp_unit_obstack, so will disappear
1111 when this compilation unit leaves the cache. */
1112 const char *scope = nullptr;
1114 /* Some data associated with the partial DIE. The tag determines
1115 which field is live. */
1118 /* The location description associated with this DIE, if any. */
1119 struct dwarf_block *locdesc;
1120 /* The offset of an import, for DW_TAG_imported_unit. */
1121 sect_offset sect_off;
1124 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1125 CORE_ADDR lowpc = 0;
1126 CORE_ADDR highpc = 0;
1128 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1129 DW_AT_sibling, if any. */
1130 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1131 could return DW_AT_sibling values to its caller load_partial_dies. */
1132 const gdb_byte *sibling = nullptr;
1134 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1135 DW_AT_specification (or DW_AT_abstract_origin or
1136 DW_AT_extension). */
1137 sect_offset spec_offset {};
1139 /* Pointers to this DIE's parent, first child, and next sibling,
1141 struct partial_die_info *die_parent = nullptr;
1142 struct partial_die_info *die_child = nullptr;
1143 struct partial_die_info *die_sibling = nullptr;
1145 friend struct partial_die_info *
1146 dwarf2_cu::find_partial_die (sect_offset sect_off);
1149 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1150 partial_die_info (sect_offset sect_off)
1151 : partial_die_info (sect_off, DW_TAG_padding, 0)
1155 partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1157 : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1162 has_specification = 0;
1165 main_subprogram = 0;
1168 has_const_value = 0;
1169 has_template_arguments = 0;
1176 /* This data structure holds the information of an abbrev. */
1179 unsigned int number; /* number identifying abbrev */
1180 enum dwarf_tag tag; /* dwarf tag */
1181 unsigned short has_children; /* boolean */
1182 unsigned short num_attrs; /* number of attributes */
1183 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1184 struct abbrev_info *next; /* next in chain */
1189 ENUM_BITFIELD(dwarf_attribute) name : 16;
1190 ENUM_BITFIELD(dwarf_form) form : 16;
1192 /* It is valid only if FORM is DW_FORM_implicit_const. */
1193 LONGEST implicit_const;
1196 /* Size of abbrev_table.abbrev_hash_table. */
1197 #define ABBREV_HASH_SIZE 121
1199 /* Top level data structure to contain an abbreviation table. */
1203 explicit abbrev_table (sect_offset off)
1207 XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1208 memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1211 DISABLE_COPY_AND_ASSIGN (abbrev_table);
1213 /* Allocate space for a struct abbrev_info object in
1215 struct abbrev_info *alloc_abbrev ();
1217 /* Add an abbreviation to the table. */
1218 void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1220 /* Look up an abbrev in the table.
1221 Returns NULL if the abbrev is not found. */
1223 struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1226 /* Where the abbrev table came from.
1227 This is used as a sanity check when the table is used. */
1228 const sect_offset sect_off;
1230 /* Storage for the abbrev table. */
1231 auto_obstack abbrev_obstack;
1235 /* Hash table of abbrevs.
1236 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1237 It could be statically allocated, but the previous code didn't so we
1239 struct abbrev_info **m_abbrevs;
1242 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1244 /* Attributes have a name and a value. */
1247 ENUM_BITFIELD(dwarf_attribute) name : 16;
1248 ENUM_BITFIELD(dwarf_form) form : 15;
1250 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1251 field should be in u.str (existing only for DW_STRING) but it is kept
1252 here for better struct attribute alignment. */
1253 unsigned int string_is_canonical : 1;
1258 struct dwarf_block *blk;
1267 /* This data structure holds a complete die structure. */
1270 /* DWARF-2 tag for this DIE. */
1271 ENUM_BITFIELD(dwarf_tag) tag : 16;
1273 /* Number of attributes */
1274 unsigned char num_attrs;
1276 /* True if we're presently building the full type name for the
1277 type derived from this DIE. */
1278 unsigned char building_fullname : 1;
1280 /* True if this die is in process. PR 16581. */
1281 unsigned char in_process : 1;
1284 unsigned int abbrev;
1286 /* Offset in .debug_info or .debug_types section. */
1287 sect_offset sect_off;
1289 /* The dies in a compilation unit form an n-ary tree. PARENT
1290 points to this die's parent; CHILD points to the first child of
1291 this node; and all the children of a given node are chained
1292 together via their SIBLING fields. */
1293 struct die_info *child; /* Its first child, if any. */
1294 struct die_info *sibling; /* Its next sibling, if any. */
1295 struct die_info *parent; /* Its parent, if any. */
1297 /* An array of attributes, with NUM_ATTRS elements. There may be
1298 zero, but it's not common and zero-sized arrays are not
1299 sufficiently portable C. */
1300 struct attribute attrs[1];
1303 /* Get at parts of an attribute structure. */
1305 #define DW_STRING(attr) ((attr)->u.str)
1306 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1307 #define DW_UNSND(attr) ((attr)->u.unsnd)
1308 #define DW_BLOCK(attr) ((attr)->u.blk)
1309 #define DW_SND(attr) ((attr)->u.snd)
1310 #define DW_ADDR(attr) ((attr)->u.addr)
1311 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1313 /* Blocks are a bunch of untyped bytes. */
1318 /* Valid only if SIZE is not zero. */
1319 const gdb_byte *data;
1322 #ifndef ATTR_ALLOC_CHUNK
1323 #define ATTR_ALLOC_CHUNK 4
1326 /* Allocate fields for structs, unions and enums in this size. */
1327 #ifndef DW_FIELD_ALLOC_CHUNK
1328 #define DW_FIELD_ALLOC_CHUNK 4
1331 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1332 but this would require a corresponding change in unpack_field_as_long
1334 static int bits_per_byte = 8;
1336 /* When reading a variant or variant part, we track a bit more
1337 information about the field, and store it in an object of this
1340 struct variant_field
1342 /* If we see a DW_TAG_variant, then this will be the discriminant
1344 ULONGEST discriminant_value;
1345 /* If we see a DW_TAG_variant, then this will be set if this is the
1347 bool default_branch;
1348 /* While reading a DW_TAG_variant_part, this will be set if this
1349 field is the discriminant. */
1350 bool is_discriminant;
1355 int accessibility = 0;
1357 /* Extra information to describe a variant or variant part. */
1358 struct variant_field variant {};
1359 struct field field {};
1364 const char *name = nullptr;
1365 std::vector<struct fn_field> fnfields;
1368 /* The routines that read and process dies for a C struct or C++ class
1369 pass lists of data member fields and lists of member function fields
1370 in an instance of a field_info structure, as defined below. */
1373 /* List of data member and baseclasses fields. */
1374 std::vector<struct nextfield> fields;
1375 std::vector<struct nextfield> baseclasses;
1377 /* Number of fields (including baseclasses). */
1380 /* Set if the accesibility of one of the fields is not public. */
1381 int non_public_fields = 0;
1383 /* Member function fieldlist array, contains name of possibly overloaded
1384 member function, number of overloaded member functions and a pointer
1385 to the head of the member function field chain. */
1386 std::vector<struct fnfieldlist> fnfieldlists;
1388 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1389 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1390 std::vector<struct decl_field> typedef_field_list;
1392 /* Nested types defined by this class and the number of elements in this
1394 std::vector<struct decl_field> nested_types_list;
1397 /* One item on the queue of compilation units to read in full symbols
1399 struct dwarf2_queue_item
1401 struct dwarf2_per_cu_data *per_cu;
1402 enum language pretend_language;
1403 struct dwarf2_queue_item *next;
1406 /* The current queue. */
1407 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1409 /* Loaded secondary compilation units are kept in memory until they
1410 have not been referenced for the processing of this many
1411 compilation units. Set this to zero to disable caching. Cache
1412 sizes of up to at least twenty will improve startup time for
1413 typical inter-CU-reference binaries, at an obvious memory cost. */
1414 static int dwarf_max_cache_age = 5;
1416 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1417 struct cmd_list_element *c, const char *value)
1419 fprintf_filtered (file, _("The upper bound on the age of cached "
1420 "DWARF compilation units is %s.\n"),
1424 /* local function prototypes */
1426 static const char *get_section_name (const struct dwarf2_section_info *);
1428 static const char *get_section_file_name (const struct dwarf2_section_info *);
1430 static void dwarf2_find_base_address (struct die_info *die,
1431 struct dwarf2_cu *cu);
1433 static struct partial_symtab *create_partial_symtab
1434 (struct dwarf2_per_cu_data *per_cu, const char *name);
1436 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1437 const gdb_byte *info_ptr,
1438 struct die_info *type_unit_die,
1439 int has_children, void *data);
1441 static void dwarf2_build_psymtabs_hard
1442 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1444 static void scan_partial_symbols (struct partial_die_info *,
1445 CORE_ADDR *, CORE_ADDR *,
1446 int, struct dwarf2_cu *);
1448 static void add_partial_symbol (struct partial_die_info *,
1449 struct dwarf2_cu *);
1451 static void add_partial_namespace (struct partial_die_info *pdi,
1452 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1453 int set_addrmap, struct dwarf2_cu *cu);
1455 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1456 CORE_ADDR *highpc, int set_addrmap,
1457 struct dwarf2_cu *cu);
1459 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1460 struct dwarf2_cu *cu);
1462 static void add_partial_subprogram (struct partial_die_info *pdi,
1463 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1464 int need_pc, struct dwarf2_cu *cu);
1466 static void dwarf2_read_symtab (struct partial_symtab *,
1469 static void psymtab_to_symtab_1 (struct partial_symtab *);
1471 static abbrev_table_up abbrev_table_read_table
1472 (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1475 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1477 static struct partial_die_info *load_partial_dies
1478 (const struct die_reader_specs *, const gdb_byte *, int);
1480 static struct partial_die_info *find_partial_die (sect_offset, int,
1481 struct dwarf2_cu *);
1483 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1484 struct attribute *, struct attr_abbrev *,
1487 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1489 static int read_1_signed_byte (bfd *, const gdb_byte *);
1491 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1493 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1495 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1497 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1500 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1502 static LONGEST read_checked_initial_length_and_offset
1503 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1504 unsigned int *, unsigned int *);
1506 static LONGEST read_offset (bfd *, const gdb_byte *,
1507 const struct comp_unit_head *,
1510 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1512 static sect_offset read_abbrev_offset
1513 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1514 struct dwarf2_section_info *, sect_offset);
1516 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1518 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1520 static const char *read_indirect_string
1521 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1522 const struct comp_unit_head *, unsigned int *);
1524 static const char *read_indirect_line_string
1525 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1526 const struct comp_unit_head *, unsigned int *);
1528 static const char *read_indirect_string_at_offset
1529 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1530 LONGEST str_offset);
1532 static const char *read_indirect_string_from_dwz
1533 (struct objfile *objfile, struct dwz_file *, LONGEST);
1535 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1537 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1541 static const char *read_str_index (const struct die_reader_specs *reader,
1542 ULONGEST str_index);
1544 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1546 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1547 struct dwarf2_cu *);
1549 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1552 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1553 struct dwarf2_cu *cu);
1555 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1556 struct dwarf2_cu *cu);
1558 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1560 static struct die_info *die_specification (struct die_info *die,
1561 struct dwarf2_cu **);
1563 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1564 struct dwarf2_cu *cu);
1566 static void dwarf_decode_lines (struct line_header *, const char *,
1567 struct dwarf2_cu *, struct partial_symtab *,
1568 CORE_ADDR, int decode_mapping);
1570 static void dwarf2_start_subfile (const char *, const char *);
1572 static struct compunit_symtab *dwarf2_start_symtab (struct dwarf2_cu *,
1573 const char *, const char *,
1576 static struct symbol *new_symbol (struct die_info *, struct type *,
1577 struct dwarf2_cu *, struct symbol * = NULL);
1579 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1580 struct dwarf2_cu *);
1582 static void dwarf2_const_value_attr (const struct attribute *attr,
1585 struct obstack *obstack,
1586 struct dwarf2_cu *cu, LONGEST *value,
1587 const gdb_byte **bytes,
1588 struct dwarf2_locexpr_baton **baton);
1590 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1592 static int need_gnat_info (struct dwarf2_cu *);
1594 static struct type *die_descriptive_type (struct die_info *,
1595 struct dwarf2_cu *);
1597 static void set_descriptive_type (struct type *, struct die_info *,
1598 struct dwarf2_cu *);
1600 static struct type *die_containing_type (struct die_info *,
1601 struct dwarf2_cu *);
1603 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1604 struct dwarf2_cu *);
1606 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1608 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1610 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1612 static char *typename_concat (struct obstack *obs, const char *prefix,
1613 const char *suffix, int physname,
1614 struct dwarf2_cu *cu);
1616 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1618 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1620 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1622 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1624 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1626 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1628 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1629 struct dwarf2_cu *, struct partial_symtab *);
1631 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1632 values. Keep the items ordered with increasing constraints compliance. */
1635 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1636 PC_BOUNDS_NOT_PRESENT,
1638 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1639 were present but they do not form a valid range of PC addresses. */
1642 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1645 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1649 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1650 CORE_ADDR *, CORE_ADDR *,
1652 struct partial_symtab *);
1654 static void get_scope_pc_bounds (struct die_info *,
1655 CORE_ADDR *, CORE_ADDR *,
1656 struct dwarf2_cu *);
1658 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1659 CORE_ADDR, struct dwarf2_cu *);
1661 static void dwarf2_add_field (struct field_info *, struct die_info *,
1662 struct dwarf2_cu *);
1664 static void dwarf2_attach_fields_to_type (struct field_info *,
1665 struct type *, struct dwarf2_cu *);
1667 static void dwarf2_add_member_fn (struct field_info *,
1668 struct die_info *, struct type *,
1669 struct dwarf2_cu *);
1671 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1673 struct dwarf2_cu *);
1675 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1677 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1679 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1681 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1683 static struct using_direct **using_directives (enum language);
1685 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1687 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1689 static struct type *read_module_type (struct die_info *die,
1690 struct dwarf2_cu *cu);
1692 static const char *namespace_name (struct die_info *die,
1693 int *is_anonymous, struct dwarf2_cu *);
1695 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1697 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1699 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1700 struct dwarf2_cu *);
1702 static struct die_info *read_die_and_siblings_1
1703 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1706 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1707 const gdb_byte *info_ptr,
1708 const gdb_byte **new_info_ptr,
1709 struct die_info *parent);
1711 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1712 struct die_info **, const gdb_byte *,
1715 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1716 struct die_info **, const gdb_byte *,
1719 static void process_die (struct die_info *, struct dwarf2_cu *);
1721 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1724 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1726 static const char *dwarf2_full_name (const char *name,
1727 struct die_info *die,
1728 struct dwarf2_cu *cu);
1730 static const char *dwarf2_physname (const char *name, struct die_info *die,
1731 struct dwarf2_cu *cu);
1733 static struct die_info *dwarf2_extension (struct die_info *die,
1734 struct dwarf2_cu **);
1736 static const char *dwarf_tag_name (unsigned int);
1738 static const char *dwarf_attr_name (unsigned int);
1740 static const char *dwarf_form_name (unsigned int);
1742 static const char *dwarf_bool_name (unsigned int);
1744 static const char *dwarf_type_encoding_name (unsigned int);
1746 static struct die_info *sibling_die (struct die_info *);
1748 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1750 static void dump_die_for_error (struct die_info *);
1752 static void dump_die_1 (struct ui_file *, int level, int max_level,
1755 /*static*/ void dump_die (struct die_info *, int max_level);
1757 static void store_in_ref_table (struct die_info *,
1758 struct dwarf2_cu *);
1760 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1762 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1764 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1765 const struct attribute *,
1766 struct dwarf2_cu **);
1768 static struct die_info *follow_die_ref (struct die_info *,
1769 const struct attribute *,
1770 struct dwarf2_cu **);
1772 static struct die_info *follow_die_sig (struct die_info *,
1773 const struct attribute *,
1774 struct dwarf2_cu **);
1776 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1777 struct dwarf2_cu *);
1779 static struct type *get_DW_AT_signature_type (struct die_info *,
1780 const struct attribute *,
1781 struct dwarf2_cu *);
1783 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1785 static void read_signatured_type (struct signatured_type *);
1787 static int attr_to_dynamic_prop (const struct attribute *attr,
1788 struct die_info *die, struct dwarf2_cu *cu,
1789 struct dynamic_prop *prop);
1791 /* memory allocation interface */
1793 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1795 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1797 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1799 static int attr_form_is_block (const struct attribute *);
1801 static int attr_form_is_section_offset (const struct attribute *);
1803 static int attr_form_is_constant (const struct attribute *);
1805 static int attr_form_is_ref (const struct attribute *);
1807 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1808 struct dwarf2_loclist_baton *baton,
1809 const struct attribute *attr);
1811 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1813 struct dwarf2_cu *cu,
1816 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1817 const gdb_byte *info_ptr,
1818 struct abbrev_info *abbrev);
1820 static hashval_t partial_die_hash (const void *item);
1822 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1824 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1825 (sect_offset sect_off, unsigned int offset_in_dwz,
1826 struct dwarf2_per_objfile *dwarf2_per_objfile);
1828 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1829 struct die_info *comp_unit_die,
1830 enum language pretend_language);
1832 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1834 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1836 static struct type *set_die_type (struct die_info *, struct type *,
1837 struct dwarf2_cu *);
1839 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1841 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1843 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1846 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1849 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1852 static void dwarf2_add_dependence (struct dwarf2_cu *,
1853 struct dwarf2_per_cu_data *);
1855 static void dwarf2_mark (struct dwarf2_cu *);
1857 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1859 static struct type *get_die_type_at_offset (sect_offset,
1860 struct dwarf2_per_cu_data *);
1862 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1864 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1865 enum language pretend_language);
1867 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1869 /* Class, the destructor of which frees all allocated queue entries. This
1870 will only have work to do if an error was thrown while processing the
1871 dwarf. If no error was thrown then the queue entries should have all
1872 been processed, and freed, as we went along. */
1874 class dwarf2_queue_guard
1877 dwarf2_queue_guard () = default;
1879 /* Free any entries remaining on the queue. There should only be
1880 entries left if we hit an error while processing the dwarf. */
1881 ~dwarf2_queue_guard ()
1883 struct dwarf2_queue_item *item, *last;
1885 item = dwarf2_queue;
1888 /* Anything still marked queued is likely to be in an
1889 inconsistent state, so discard it. */
1890 if (item->per_cu->queued)
1892 if (item->per_cu->cu != NULL)
1893 free_one_cached_comp_unit (item->per_cu);
1894 item->per_cu->queued = 0;
1902 dwarf2_queue = dwarf2_queue_tail = NULL;
1906 /* The return type of find_file_and_directory. Note, the enclosed
1907 string pointers are only valid while this object is valid. */
1909 struct file_and_directory
1911 /* The filename. This is never NULL. */
1914 /* The compilation directory. NULL if not known. If we needed to
1915 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1916 points directly to the DW_AT_comp_dir string attribute owned by
1917 the obstack that owns the DIE. */
1918 const char *comp_dir;
1920 /* If we needed to build a new string for comp_dir, this is what
1921 owns the storage. */
1922 std::string comp_dir_storage;
1925 static file_and_directory find_file_and_directory (struct die_info *die,
1926 struct dwarf2_cu *cu);
1928 static char *file_full_name (int file, struct line_header *lh,
1929 const char *comp_dir);
1931 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1932 enum class rcuh_kind { COMPILE, TYPE };
1934 static const gdb_byte *read_and_check_comp_unit_head
1935 (struct dwarf2_per_objfile* dwarf2_per_objfile,
1936 struct comp_unit_head *header,
1937 struct dwarf2_section_info *section,
1938 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1939 rcuh_kind section_kind);
1941 static void init_cutu_and_read_dies
1942 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1943 int use_existing_cu, int keep, bool skip_partial,
1944 die_reader_func_ftype *die_reader_func, void *data);
1946 static void init_cutu_and_read_dies_simple
1947 (struct dwarf2_per_cu_data *this_cu,
1948 die_reader_func_ftype *die_reader_func, void *data);
1950 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1952 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1954 static struct dwo_unit *lookup_dwo_unit_in_dwp
1955 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1956 struct dwp_file *dwp_file, const char *comp_dir,
1957 ULONGEST signature, int is_debug_types);
1959 static struct dwp_file *get_dwp_file
1960 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1962 static struct dwo_unit *lookup_dwo_comp_unit
1963 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1965 static struct dwo_unit *lookup_dwo_type_unit
1966 (struct signatured_type *, const char *, const char *);
1968 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1970 static void free_dwo_file (struct dwo_file *);
1972 /* A unique_ptr helper to free a dwo_file. */
1974 struct dwo_file_deleter
1976 void operator() (struct dwo_file *df) const
1982 /* A unique pointer to a dwo_file. */
1984 typedef std::unique_ptr<struct dwo_file, dwo_file_deleter> dwo_file_up;
1986 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
1988 static void check_producer (struct dwarf2_cu *cu);
1990 static void free_line_header_voidp (void *arg);
1992 /* Various complaints about symbol reading that don't abort the process. */
1995 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1997 complaint (&symfile_complaints,
1998 _("statement list doesn't fit in .debug_line section"));
2002 dwarf2_debug_line_missing_file_complaint (void)
2004 complaint (&symfile_complaints,
2005 _(".debug_line section has line data without a file"));
2009 dwarf2_debug_line_missing_end_sequence_complaint (void)
2011 complaint (&symfile_complaints,
2012 _(".debug_line section has line "
2013 "program sequence without an end"));
2017 dwarf2_complex_location_expr_complaint (void)
2019 complaint (&symfile_complaints, _("location expression too complex"));
2023 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2026 complaint (&symfile_complaints,
2027 _("const value length mismatch for '%s', got %d, expected %d"),
2032 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2034 complaint (&symfile_complaints,
2035 _("debug info runs off end of %s section"
2037 get_section_name (section),
2038 get_section_file_name (section));
2042 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2044 complaint (&symfile_complaints,
2045 _("macro debug info contains a "
2046 "malformed macro definition:\n`%s'"),
2051 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2053 complaint (&symfile_complaints,
2054 _("invalid attribute class or form for '%s' in '%s'"),
2058 /* Hash function for line_header_hash. */
2061 line_header_hash (const struct line_header *ofs)
2063 return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2066 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2069 line_header_hash_voidp (const void *item)
2071 const struct line_header *ofs = (const struct line_header *) item;
2073 return line_header_hash (ofs);
2076 /* Equality function for line_header_hash. */
2079 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2081 const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2082 const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2084 return (ofs_lhs->sect_off == ofs_rhs->sect_off
2085 && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2090 /* Read the given attribute value as an address, taking the attribute's
2091 form into account. */
2094 attr_value_as_address (struct attribute *attr)
2098 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2100 /* Aside from a few clearly defined exceptions, attributes that
2101 contain an address must always be in DW_FORM_addr form.
2102 Unfortunately, some compilers happen to be violating this
2103 requirement by encoding addresses using other forms, such
2104 as DW_FORM_data4 for example. For those broken compilers,
2105 we try to do our best, without any guarantee of success,
2106 to interpret the address correctly. It would also be nice
2107 to generate a complaint, but that would require us to maintain
2108 a list of legitimate cases where a non-address form is allowed,
2109 as well as update callers to pass in at least the CU's DWARF
2110 version. This is more overhead than what we're willing to
2111 expand for a pretty rare case. */
2112 addr = DW_UNSND (attr);
2115 addr = DW_ADDR (attr);
2120 /* See declaration. */
2122 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2123 const dwarf2_debug_sections *names)
2124 : objfile (objfile_)
2127 names = &dwarf2_elf_names;
2129 bfd *obfd = objfile->obfd;
2131 for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2132 locate_sections (obfd, sec, *names);
2135 static void free_dwo_files (htab_t dwo_files, struct objfile *objfile);
2137 dwarf2_per_objfile::~dwarf2_per_objfile ()
2139 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2140 free_cached_comp_units ();
2142 if (quick_file_names_table)
2143 htab_delete (quick_file_names_table);
2145 if (line_header_hash)
2146 htab_delete (line_header_hash);
2148 for (dwarf2_per_cu_data *per_cu : all_comp_units)
2149 VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
2151 for (signatured_type *sig_type : all_type_units)
2152 VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
2154 VEC_free (dwarf2_section_info_def, types);
2156 if (dwo_files != NULL)
2157 free_dwo_files (dwo_files, objfile);
2159 /* Everything else should be on the objfile obstack. */
2162 /* See declaration. */
2165 dwarf2_per_objfile::free_cached_comp_units ()
2167 dwarf2_per_cu_data *per_cu = read_in_chain;
2168 dwarf2_per_cu_data **last_chain = &read_in_chain;
2169 while (per_cu != NULL)
2171 dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2174 *last_chain = next_cu;
2179 /* A helper class that calls free_cached_comp_units on
2182 class free_cached_comp_units
2186 explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2187 : m_per_objfile (per_objfile)
2191 ~free_cached_comp_units ()
2193 m_per_objfile->free_cached_comp_units ();
2196 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2200 dwarf2_per_objfile *m_per_objfile;
2203 /* Try to locate the sections we need for DWARF 2 debugging
2204 information and return true if we have enough to do something.
2205 NAMES points to the dwarf2 section names, or is NULL if the standard
2206 ELF names are used. */
2209 dwarf2_has_info (struct objfile *objfile,
2210 const struct dwarf2_debug_sections *names)
2212 if (objfile->flags & OBJF_READNEVER)
2215 struct dwarf2_per_objfile *dwarf2_per_objfile
2216 = get_dwarf2_per_objfile (objfile);
2218 if (dwarf2_per_objfile == NULL)
2220 /* Initialize per-objfile state. */
2222 = new (&objfile->objfile_obstack) struct dwarf2_per_objfile (objfile,
2224 set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2226 return (!dwarf2_per_objfile->info.is_virtual
2227 && dwarf2_per_objfile->info.s.section != NULL
2228 && !dwarf2_per_objfile->abbrev.is_virtual
2229 && dwarf2_per_objfile->abbrev.s.section != NULL);
2232 /* Return the containing section of virtual section SECTION. */
2234 static struct dwarf2_section_info *
2235 get_containing_section (const struct dwarf2_section_info *section)
2237 gdb_assert (section->is_virtual);
2238 return section->s.containing_section;
2241 /* Return the bfd owner of SECTION. */
2244 get_section_bfd_owner (const struct dwarf2_section_info *section)
2246 if (section->is_virtual)
2248 section = get_containing_section (section);
2249 gdb_assert (!section->is_virtual);
2251 return section->s.section->owner;
2254 /* Return the bfd section of SECTION.
2255 Returns NULL if the section is not present. */
2258 get_section_bfd_section (const struct dwarf2_section_info *section)
2260 if (section->is_virtual)
2262 section = get_containing_section (section);
2263 gdb_assert (!section->is_virtual);
2265 return section->s.section;
2268 /* Return the name of SECTION. */
2271 get_section_name (const struct dwarf2_section_info *section)
2273 asection *sectp = get_section_bfd_section (section);
2275 gdb_assert (sectp != NULL);
2276 return bfd_section_name (get_section_bfd_owner (section), sectp);
2279 /* Return the name of the file SECTION is in. */
2282 get_section_file_name (const struct dwarf2_section_info *section)
2284 bfd *abfd = get_section_bfd_owner (section);
2286 return bfd_get_filename (abfd);
2289 /* Return the id of SECTION.
2290 Returns 0 if SECTION doesn't exist. */
2293 get_section_id (const struct dwarf2_section_info *section)
2295 asection *sectp = get_section_bfd_section (section);
2302 /* Return the flags of SECTION.
2303 SECTION (or containing section if this is a virtual section) must exist. */
2306 get_section_flags (const struct dwarf2_section_info *section)
2308 asection *sectp = get_section_bfd_section (section);
2310 gdb_assert (sectp != NULL);
2311 return bfd_get_section_flags (sectp->owner, sectp);
2314 /* When loading sections, we look either for uncompressed section or for
2315 compressed section names. */
2318 section_is_p (const char *section_name,
2319 const struct dwarf2_section_names *names)
2321 if (names->normal != NULL
2322 && strcmp (section_name, names->normal) == 0)
2324 if (names->compressed != NULL
2325 && strcmp (section_name, names->compressed) == 0)
2330 /* See declaration. */
2333 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2334 const dwarf2_debug_sections &names)
2336 flagword aflag = bfd_get_section_flags (abfd, sectp);
2338 if ((aflag & SEC_HAS_CONTENTS) == 0)
2341 else if (section_is_p (sectp->name, &names.info))
2343 this->info.s.section = sectp;
2344 this->info.size = bfd_get_section_size (sectp);
2346 else if (section_is_p (sectp->name, &names.abbrev))
2348 this->abbrev.s.section = sectp;
2349 this->abbrev.size = bfd_get_section_size (sectp);
2351 else if (section_is_p (sectp->name, &names.line))
2353 this->line.s.section = sectp;
2354 this->line.size = bfd_get_section_size (sectp);
2356 else if (section_is_p (sectp->name, &names.loc))
2358 this->loc.s.section = sectp;
2359 this->loc.size = bfd_get_section_size (sectp);
2361 else if (section_is_p (sectp->name, &names.loclists))
2363 this->loclists.s.section = sectp;
2364 this->loclists.size = bfd_get_section_size (sectp);
2366 else if (section_is_p (sectp->name, &names.macinfo))
2368 this->macinfo.s.section = sectp;
2369 this->macinfo.size = bfd_get_section_size (sectp);
2371 else if (section_is_p (sectp->name, &names.macro))
2373 this->macro.s.section = sectp;
2374 this->macro.size = bfd_get_section_size (sectp);
2376 else if (section_is_p (sectp->name, &names.str))
2378 this->str.s.section = sectp;
2379 this->str.size = bfd_get_section_size (sectp);
2381 else if (section_is_p (sectp->name, &names.line_str))
2383 this->line_str.s.section = sectp;
2384 this->line_str.size = bfd_get_section_size (sectp);
2386 else if (section_is_p (sectp->name, &names.addr))
2388 this->addr.s.section = sectp;
2389 this->addr.size = bfd_get_section_size (sectp);
2391 else if (section_is_p (sectp->name, &names.frame))
2393 this->frame.s.section = sectp;
2394 this->frame.size = bfd_get_section_size (sectp);
2396 else if (section_is_p (sectp->name, &names.eh_frame))
2398 this->eh_frame.s.section = sectp;
2399 this->eh_frame.size = bfd_get_section_size (sectp);
2401 else if (section_is_p (sectp->name, &names.ranges))
2403 this->ranges.s.section = sectp;
2404 this->ranges.size = bfd_get_section_size (sectp);
2406 else if (section_is_p (sectp->name, &names.rnglists))
2408 this->rnglists.s.section = sectp;
2409 this->rnglists.size = bfd_get_section_size (sectp);
2411 else if (section_is_p (sectp->name, &names.types))
2413 struct dwarf2_section_info type_section;
2415 memset (&type_section, 0, sizeof (type_section));
2416 type_section.s.section = sectp;
2417 type_section.size = bfd_get_section_size (sectp);
2419 VEC_safe_push (dwarf2_section_info_def, this->types,
2422 else if (section_is_p (sectp->name, &names.gdb_index))
2424 this->gdb_index.s.section = sectp;
2425 this->gdb_index.size = bfd_get_section_size (sectp);
2427 else if (section_is_p (sectp->name, &names.debug_names))
2429 this->debug_names.s.section = sectp;
2430 this->debug_names.size = bfd_get_section_size (sectp);
2432 else if (section_is_p (sectp->name, &names.debug_aranges))
2434 this->debug_aranges.s.section = sectp;
2435 this->debug_aranges.size = bfd_get_section_size (sectp);
2438 if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2439 && bfd_section_vma (abfd, sectp) == 0)
2440 this->has_section_at_zero = true;
2443 /* A helper function that decides whether a section is empty,
2447 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2449 if (section->is_virtual)
2450 return section->size == 0;
2451 return section->s.section == NULL || section->size == 0;
2454 /* See dwarf2read.h. */
2457 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2461 gdb_byte *buf, *retbuf;
2465 info->buffer = NULL;
2468 if (dwarf2_section_empty_p (info))
2471 sectp = get_section_bfd_section (info);
2473 /* If this is a virtual section we need to read in the real one first. */
2474 if (info->is_virtual)
2476 struct dwarf2_section_info *containing_section =
2477 get_containing_section (info);
2479 gdb_assert (sectp != NULL);
2480 if ((sectp->flags & SEC_RELOC) != 0)
2482 error (_("Dwarf Error: DWP format V2 with relocations is not"
2483 " supported in section %s [in module %s]"),
2484 get_section_name (info), get_section_file_name (info));
2486 dwarf2_read_section (objfile, containing_section);
2487 /* Other code should have already caught virtual sections that don't
2489 gdb_assert (info->virtual_offset + info->size
2490 <= containing_section->size);
2491 /* If the real section is empty or there was a problem reading the
2492 section we shouldn't get here. */
2493 gdb_assert (containing_section->buffer != NULL);
2494 info->buffer = containing_section->buffer + info->virtual_offset;
2498 /* If the section has relocations, we must read it ourselves.
2499 Otherwise we attach it to the BFD. */
2500 if ((sectp->flags & SEC_RELOC) == 0)
2502 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2506 buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2509 /* When debugging .o files, we may need to apply relocations; see
2510 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2511 We never compress sections in .o files, so we only need to
2512 try this when the section is not compressed. */
2513 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2516 info->buffer = retbuf;
2520 abfd = get_section_bfd_owner (info);
2521 gdb_assert (abfd != NULL);
2523 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2524 || bfd_bread (buf, info->size, abfd) != info->size)
2526 error (_("Dwarf Error: Can't read DWARF data"
2527 " in section %s [in module %s]"),
2528 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2532 /* A helper function that returns the size of a section in a safe way.
2533 If you are positive that the section has been read before using the
2534 size, then it is safe to refer to the dwarf2_section_info object's
2535 "size" field directly. In other cases, you must call this
2536 function, because for compressed sections the size field is not set
2537 correctly until the section has been read. */
2539 static bfd_size_type
2540 dwarf2_section_size (struct objfile *objfile,
2541 struct dwarf2_section_info *info)
2544 dwarf2_read_section (objfile, info);
2548 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2552 dwarf2_get_section_info (struct objfile *objfile,
2553 enum dwarf2_section_enum sect,
2554 asection **sectp, const gdb_byte **bufp,
2555 bfd_size_type *sizep)
2557 struct dwarf2_per_objfile *data
2558 = (struct dwarf2_per_objfile *) objfile_data (objfile,
2559 dwarf2_objfile_data_key);
2560 struct dwarf2_section_info *info;
2562 /* We may see an objfile without any DWARF, in which case we just
2573 case DWARF2_DEBUG_FRAME:
2574 info = &data->frame;
2576 case DWARF2_EH_FRAME:
2577 info = &data->eh_frame;
2580 gdb_assert_not_reached ("unexpected section");
2583 dwarf2_read_section (objfile, info);
2585 *sectp = get_section_bfd_section (info);
2586 *bufp = info->buffer;
2587 *sizep = info->size;
2590 /* A helper function to find the sections for a .dwz file. */
2593 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2595 struct dwz_file *dwz_file = (struct dwz_file *) arg;
2597 /* Note that we only support the standard ELF names, because .dwz
2598 is ELF-only (at the time of writing). */
2599 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2601 dwz_file->abbrev.s.section = sectp;
2602 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2604 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2606 dwz_file->info.s.section = sectp;
2607 dwz_file->info.size = bfd_get_section_size (sectp);
2609 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2611 dwz_file->str.s.section = sectp;
2612 dwz_file->str.size = bfd_get_section_size (sectp);
2614 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2616 dwz_file->line.s.section = sectp;
2617 dwz_file->line.size = bfd_get_section_size (sectp);
2619 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2621 dwz_file->macro.s.section = sectp;
2622 dwz_file->macro.size = bfd_get_section_size (sectp);
2624 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2626 dwz_file->gdb_index.s.section = sectp;
2627 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2629 else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2631 dwz_file->debug_names.s.section = sectp;
2632 dwz_file->debug_names.size = bfd_get_section_size (sectp);
2636 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2637 there is no .gnu_debugaltlink section in the file. Error if there
2638 is such a section but the file cannot be found. */
2640 static struct dwz_file *
2641 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2643 const char *filename;
2644 bfd_size_type buildid_len_arg;
2648 if (dwarf2_per_objfile->dwz_file != NULL)
2649 return dwarf2_per_objfile->dwz_file.get ();
2651 bfd_set_error (bfd_error_no_error);
2652 gdb::unique_xmalloc_ptr<char> data
2653 (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2654 &buildid_len_arg, &buildid));
2657 if (bfd_get_error () == bfd_error_no_error)
2659 error (_("could not read '.gnu_debugaltlink' section: %s"),
2660 bfd_errmsg (bfd_get_error ()));
2663 gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2665 buildid_len = (size_t) buildid_len_arg;
2667 filename = data.get ();
2669 std::string abs_storage;
2670 if (!IS_ABSOLUTE_PATH (filename))
2672 gdb::unique_xmalloc_ptr<char> abs
2673 = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2675 abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2676 filename = abs_storage.c_str ();
2679 /* First try the file name given in the section. If that doesn't
2680 work, try to use the build-id instead. */
2681 gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2682 if (dwz_bfd != NULL)
2684 if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2688 if (dwz_bfd == NULL)
2689 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2691 if (dwz_bfd == NULL)
2692 error (_("could not find '.gnu_debugaltlink' file for %s"),
2693 objfile_name (dwarf2_per_objfile->objfile));
2695 std::unique_ptr<struct dwz_file> result
2696 (new struct dwz_file (std::move (dwz_bfd)));
2698 bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2701 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2702 result->dwz_bfd.get ());
2703 dwarf2_per_objfile->dwz_file = std::move (result);
2704 return dwarf2_per_objfile->dwz_file.get ();
2707 /* DWARF quick_symbols_functions support. */
2709 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2710 unique line tables, so we maintain a separate table of all .debug_line
2711 derived entries to support the sharing.
2712 All the quick functions need is the list of file names. We discard the
2713 line_header when we're done and don't need to record it here. */
2714 struct quick_file_names
2716 /* The data used to construct the hash key. */
2717 struct stmt_list_hash hash;
2719 /* The number of entries in file_names, real_names. */
2720 unsigned int num_file_names;
2722 /* The file names from the line table, after being run through
2724 const char **file_names;
2726 /* The file names from the line table after being run through
2727 gdb_realpath. These are computed lazily. */
2728 const char **real_names;
2731 /* When using the index (and thus not using psymtabs), each CU has an
2732 object of this type. This is used to hold information needed by
2733 the various "quick" methods. */
2734 struct dwarf2_per_cu_quick_data
2736 /* The file table. This can be NULL if there was no file table
2737 or it's currently not read in.
2738 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2739 struct quick_file_names *file_names;
2741 /* The corresponding symbol table. This is NULL if symbols for this
2742 CU have not yet been read. */
2743 struct compunit_symtab *compunit_symtab;
2745 /* A temporary mark bit used when iterating over all CUs in
2746 expand_symtabs_matching. */
2747 unsigned int mark : 1;
2749 /* True if we've tried to read the file table and found there isn't one.
2750 There will be no point in trying to read it again next time. */
2751 unsigned int no_file_data : 1;
2754 /* Utility hash function for a stmt_list_hash. */
2757 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2761 if (stmt_list_hash->dwo_unit != NULL)
2762 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2763 v += to_underlying (stmt_list_hash->line_sect_off);
2767 /* Utility equality function for a stmt_list_hash. */
2770 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2771 const struct stmt_list_hash *rhs)
2773 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2775 if (lhs->dwo_unit != NULL
2776 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2779 return lhs->line_sect_off == rhs->line_sect_off;
2782 /* Hash function for a quick_file_names. */
2785 hash_file_name_entry (const void *e)
2787 const struct quick_file_names *file_data
2788 = (const struct quick_file_names *) e;
2790 return hash_stmt_list_entry (&file_data->hash);
2793 /* Equality function for a quick_file_names. */
2796 eq_file_name_entry (const void *a, const void *b)
2798 const struct quick_file_names *ea = (const struct quick_file_names *) a;
2799 const struct quick_file_names *eb = (const struct quick_file_names *) b;
2801 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2804 /* Delete function for a quick_file_names. */
2807 delete_file_name_entry (void *e)
2809 struct quick_file_names *file_data = (struct quick_file_names *) e;
2812 for (i = 0; i < file_data->num_file_names; ++i)
2814 xfree ((void*) file_data->file_names[i]);
2815 if (file_data->real_names)
2816 xfree ((void*) file_data->real_names[i]);
2819 /* The space for the struct itself lives on objfile_obstack,
2820 so we don't free it here. */
2823 /* Create a quick_file_names hash table. */
2826 create_quick_file_names_table (unsigned int nr_initial_entries)
2828 return htab_create_alloc (nr_initial_entries,
2829 hash_file_name_entry, eq_file_name_entry,
2830 delete_file_name_entry, xcalloc, xfree);
2833 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2834 have to be created afterwards. You should call age_cached_comp_units after
2835 processing PER_CU->CU. dw2_setup must have been already called. */
2838 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2840 if (per_cu->is_debug_types)
2841 load_full_type_unit (per_cu);
2843 load_full_comp_unit (per_cu, skip_partial, language_minimal);
2845 if (per_cu->cu == NULL)
2846 return; /* Dummy CU. */
2848 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2851 /* Read in the symbols for PER_CU. */
2854 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2856 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2858 /* Skip type_unit_groups, reading the type units they contain
2859 is handled elsewhere. */
2860 if (IS_TYPE_UNIT_GROUP (per_cu))
2863 /* The destructor of dwarf2_queue_guard frees any entries left on
2864 the queue. After this point we're guaranteed to leave this function
2865 with the dwarf queue empty. */
2866 dwarf2_queue_guard q_guard;
2868 if (dwarf2_per_objfile->using_index
2869 ? per_cu->v.quick->compunit_symtab == NULL
2870 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2872 queue_comp_unit (per_cu, language_minimal);
2873 load_cu (per_cu, skip_partial);
2875 /* If we just loaded a CU from a DWO, and we're working with an index
2876 that may badly handle TUs, load all the TUs in that DWO as well.
2877 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2878 if (!per_cu->is_debug_types
2879 && per_cu->cu != NULL
2880 && per_cu->cu->dwo_unit != NULL
2881 && dwarf2_per_objfile->index_table != NULL
2882 && dwarf2_per_objfile->index_table->version <= 7
2883 /* DWP files aren't supported yet. */
2884 && get_dwp_file (dwarf2_per_objfile) == NULL)
2885 queue_and_load_all_dwo_tus (per_cu);
2888 process_queue (dwarf2_per_objfile);
2890 /* Age the cache, releasing compilation units that have not
2891 been used recently. */
2892 age_cached_comp_units (dwarf2_per_objfile);
2895 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2896 the objfile from which this CU came. Returns the resulting symbol
2899 static struct compunit_symtab *
2900 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2902 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2904 gdb_assert (dwarf2_per_objfile->using_index);
2905 if (!per_cu->v.quick->compunit_symtab)
2907 free_cached_comp_units freer (dwarf2_per_objfile);
2908 scoped_restore decrementer = increment_reading_symtab ();
2909 dw2_do_instantiate_symtab (per_cu, skip_partial);
2910 process_cu_includes (dwarf2_per_objfile);
2913 return per_cu->v.quick->compunit_symtab;
2916 /* See declaration. */
2918 dwarf2_per_cu_data *
2919 dwarf2_per_objfile::get_cutu (int index)
2921 if (index >= this->all_comp_units.size ())
2923 index -= this->all_comp_units.size ();
2924 gdb_assert (index < this->all_type_units.size ());
2925 return &this->all_type_units[index]->per_cu;
2928 return this->all_comp_units[index];
2931 /* See declaration. */
2933 dwarf2_per_cu_data *
2934 dwarf2_per_objfile::get_cu (int index)
2936 gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2938 return this->all_comp_units[index];
2941 /* See declaration. */
2944 dwarf2_per_objfile::get_tu (int index)
2946 gdb_assert (index >= 0 && index < this->all_type_units.size ());
2948 return this->all_type_units[index];
2951 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2952 objfile_obstack, and constructed with the specified field
2955 static dwarf2_per_cu_data *
2956 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2957 struct dwarf2_section_info *section,
2959 sect_offset sect_off, ULONGEST length)
2961 struct objfile *objfile = dwarf2_per_objfile->objfile;
2962 dwarf2_per_cu_data *the_cu
2963 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2964 struct dwarf2_per_cu_data);
2965 the_cu->sect_off = sect_off;
2966 the_cu->length = length;
2967 the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
2968 the_cu->section = section;
2969 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2970 struct dwarf2_per_cu_quick_data);
2971 the_cu->is_dwz = is_dwz;
2975 /* A helper for create_cus_from_index that handles a given list of
2979 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2980 const gdb_byte *cu_list, offset_type n_elements,
2981 struct dwarf2_section_info *section,
2984 for (offset_type i = 0; i < n_elements; i += 2)
2986 gdb_static_assert (sizeof (ULONGEST) >= 8);
2988 sect_offset sect_off
2989 = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2990 ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
2993 dwarf2_per_cu_data *per_cu
2994 = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
2996 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
3000 /* Read the CU list from the mapped index, and use it to create all
3001 the CU objects for this objfile. */
3004 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3005 const gdb_byte *cu_list, offset_type cu_list_elements,
3006 const gdb_byte *dwz_list, offset_type dwz_elements)
3008 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3009 dwarf2_per_objfile->all_comp_units.reserve
3010 ((cu_list_elements + dwz_elements) / 2);
3012 create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3013 &dwarf2_per_objfile->info, 0);
3015 if (dwz_elements == 0)
3018 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3019 create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3023 /* Create the signatured type hash table from the index. */
3026 create_signatured_type_table_from_index
3027 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3028 struct dwarf2_section_info *section,
3029 const gdb_byte *bytes,
3030 offset_type elements)
3032 struct objfile *objfile = dwarf2_per_objfile->objfile;
3034 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3035 dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3037 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3039 for (offset_type i = 0; i < elements; i += 3)
3041 struct signatured_type *sig_type;
3044 cu_offset type_offset_in_tu;
3046 gdb_static_assert (sizeof (ULONGEST) >= 8);
3047 sect_offset sect_off
3048 = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3050 = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3052 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3055 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3056 struct signatured_type);
3057 sig_type->signature = signature;
3058 sig_type->type_offset_in_tu = type_offset_in_tu;
3059 sig_type->per_cu.is_debug_types = 1;
3060 sig_type->per_cu.section = section;
3061 sig_type->per_cu.sect_off = sect_off;
3062 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3063 sig_type->per_cu.v.quick
3064 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3065 struct dwarf2_per_cu_quick_data);
3067 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3070 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3073 dwarf2_per_objfile->signatured_types = sig_types_hash;
3076 /* Create the signatured type hash table from .debug_names. */
3079 create_signatured_type_table_from_debug_names
3080 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3081 const mapped_debug_names &map,
3082 struct dwarf2_section_info *section,
3083 struct dwarf2_section_info *abbrev_section)
3085 struct objfile *objfile = dwarf2_per_objfile->objfile;
3087 dwarf2_read_section (objfile, section);
3088 dwarf2_read_section (objfile, abbrev_section);
3090 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3091 dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3093 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3095 for (uint32_t i = 0; i < map.tu_count; ++i)
3097 struct signatured_type *sig_type;
3100 sect_offset sect_off
3101 = (sect_offset) (extract_unsigned_integer
3102 (map.tu_table_reordered + i * map.offset_size,
3104 map.dwarf5_byte_order));
3106 comp_unit_head cu_header;
3107 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3109 section->buffer + to_underlying (sect_off),
3112 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3113 struct signatured_type);
3114 sig_type->signature = cu_header.signature;
3115 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3116 sig_type->per_cu.is_debug_types = 1;
3117 sig_type->per_cu.section = section;
3118 sig_type->per_cu.sect_off = sect_off;
3119 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3120 sig_type->per_cu.v.quick
3121 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3122 struct dwarf2_per_cu_quick_data);
3124 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3127 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3130 dwarf2_per_objfile->signatured_types = sig_types_hash;
3133 /* Read the address map data from the mapped index, and use it to
3134 populate the objfile's psymtabs_addrmap. */
3137 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3138 struct mapped_index *index)
3140 struct objfile *objfile = dwarf2_per_objfile->objfile;
3141 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3142 const gdb_byte *iter, *end;
3143 struct addrmap *mutable_map;
3146 auto_obstack temp_obstack;
3148 mutable_map = addrmap_create_mutable (&temp_obstack);
3150 iter = index->address_table.data ();
3151 end = iter + index->address_table.size ();
3153 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3157 ULONGEST hi, lo, cu_index;
3158 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3160 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3162 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3167 complaint (&symfile_complaints,
3168 _(".gdb_index address table has invalid range (%s - %s)"),
3169 hex_string (lo), hex_string (hi));
3173 if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3175 complaint (&symfile_complaints,
3176 _(".gdb_index address table has invalid CU number %u"),
3177 (unsigned) cu_index);
3181 lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr);
3182 hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr);
3183 addrmap_set_empty (mutable_map, lo, hi - 1,
3184 dwarf2_per_objfile->get_cu (cu_index));
3187 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3188 &objfile->objfile_obstack);
3191 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3192 populate the objfile's psymtabs_addrmap. */
3195 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3196 struct dwarf2_section_info *section)
3198 struct objfile *objfile = dwarf2_per_objfile->objfile;
3199 bfd *abfd = objfile->obfd;
3200 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3201 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3202 SECT_OFF_TEXT (objfile));
3204 auto_obstack temp_obstack;
3205 addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3207 std::unordered_map<sect_offset,
3208 dwarf2_per_cu_data *,
3209 gdb::hash_enum<sect_offset>>
3210 debug_info_offset_to_per_cu;
3211 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3213 const auto insertpair
3214 = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3215 if (!insertpair.second)
3217 warning (_("Section .debug_aranges in %s has duplicate "
3218 "debug_info_offset %s, ignoring .debug_aranges."),
3219 objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3224 dwarf2_read_section (objfile, section);
3226 const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3228 const gdb_byte *addr = section->buffer;
3230 while (addr < section->buffer + section->size)
3232 const gdb_byte *const entry_addr = addr;
3233 unsigned int bytes_read;
3235 const LONGEST entry_length = read_initial_length (abfd, addr,
3239 const gdb_byte *const entry_end = addr + entry_length;
3240 const bool dwarf5_is_dwarf64 = bytes_read != 4;
3241 const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3242 if (addr + entry_length > section->buffer + section->size)
3244 warning (_("Section .debug_aranges in %s entry at offset %zu "
3245 "length %s exceeds section length %s, "
3246 "ignoring .debug_aranges."),
3247 objfile_name (objfile), entry_addr - section->buffer,
3248 plongest (bytes_read + entry_length),
3249 pulongest (section->size));
3253 /* The version number. */
3254 const uint16_t version = read_2_bytes (abfd, addr);
3258 warning (_("Section .debug_aranges in %s entry at offset %zu "
3259 "has unsupported version %d, ignoring .debug_aranges."),
3260 objfile_name (objfile), entry_addr - section->buffer,
3265 const uint64_t debug_info_offset
3266 = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3267 addr += offset_size;
3268 const auto per_cu_it
3269 = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3270 if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3272 warning (_("Section .debug_aranges in %s entry at offset %zu "
3273 "debug_info_offset %s does not exists, "
3274 "ignoring .debug_aranges."),
3275 objfile_name (objfile), entry_addr - section->buffer,
3276 pulongest (debug_info_offset));
3279 dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3281 const uint8_t address_size = *addr++;
3282 if (address_size < 1 || address_size > 8)
3284 warning (_("Section .debug_aranges in %s entry at offset %zu "
3285 "address_size %u is invalid, ignoring .debug_aranges."),
3286 objfile_name (objfile), entry_addr - section->buffer,
3291 const uint8_t segment_selector_size = *addr++;
3292 if (segment_selector_size != 0)
3294 warning (_("Section .debug_aranges in %s entry at offset %zu "
3295 "segment_selector_size %u is not supported, "
3296 "ignoring .debug_aranges."),
3297 objfile_name (objfile), entry_addr - section->buffer,
3298 segment_selector_size);
3302 /* Must pad to an alignment boundary that is twice the address
3303 size. It is undocumented by the DWARF standard but GCC does
3305 for (size_t padding = ((-(addr - section->buffer))
3306 & (2 * address_size - 1));
3307 padding > 0; padding--)
3310 warning (_("Section .debug_aranges in %s entry at offset %zu "
3311 "padding is not zero, ignoring .debug_aranges."),
3312 objfile_name (objfile), entry_addr - section->buffer);
3318 if (addr + 2 * address_size > entry_end)
3320 warning (_("Section .debug_aranges in %s entry at offset %zu "
3321 "address list is not properly terminated, "
3322 "ignoring .debug_aranges."),
3323 objfile_name (objfile), entry_addr - section->buffer);
3326 ULONGEST start = extract_unsigned_integer (addr, address_size,
3328 addr += address_size;
3329 ULONGEST length = extract_unsigned_integer (addr, address_size,
3331 addr += address_size;
3332 if (start == 0 && length == 0)
3334 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3336 /* Symbol was eliminated due to a COMDAT group. */
3339 ULONGEST end = start + length;
3340 start = gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr);
3341 end = gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr);
3342 addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3346 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3347 &objfile->objfile_obstack);
3350 /* Find a slot in the mapped index INDEX for the object named NAME.
3351 If NAME is found, set *VEC_OUT to point to the CU vector in the
3352 constant pool and return true. If NAME cannot be found, return
3356 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3357 offset_type **vec_out)
3360 offset_type slot, step;
3361 int (*cmp) (const char *, const char *);
3363 gdb::unique_xmalloc_ptr<char> without_params;
3364 if (current_language->la_language == language_cplus
3365 || current_language->la_language == language_fortran
3366 || current_language->la_language == language_d)
3368 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3371 if (strchr (name, '(') != NULL)
3373 without_params = cp_remove_params (name);
3375 if (without_params != NULL)
3376 name = without_params.get ();
3380 /* Index version 4 did not support case insensitive searches. But the
3381 indices for case insensitive languages are built in lowercase, therefore
3382 simulate our NAME being searched is also lowercased. */
3383 hash = mapped_index_string_hash ((index->version == 4
3384 && case_sensitivity == case_sensitive_off
3385 ? 5 : index->version),
3388 slot = hash & (index->symbol_table.size () - 1);
3389 step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3390 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3396 const auto &bucket = index->symbol_table[slot];
3397 if (bucket.name == 0 && bucket.vec == 0)
3400 str = index->constant_pool + MAYBE_SWAP (bucket.name);
3401 if (!cmp (name, str))
3403 *vec_out = (offset_type *) (index->constant_pool
3404 + MAYBE_SWAP (bucket.vec));
3408 slot = (slot + step) & (index->symbol_table.size () - 1);
3412 /* A helper function that reads the .gdb_index from SECTION and fills
3413 in MAP. FILENAME is the name of the file containing the section;
3414 it is used for error reporting. DEPRECATED_OK is true if it is
3415 ok to use deprecated sections.
3417 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3418 out parameters that are filled in with information about the CU and
3419 TU lists in the section.
3421 Returns 1 if all went well, 0 otherwise. */
3424 read_index_from_section (struct objfile *objfile,
3425 const char *filename,
3427 struct dwarf2_section_info *section,
3428 struct mapped_index *map,
3429 const gdb_byte **cu_list,
3430 offset_type *cu_list_elements,
3431 const gdb_byte **types_list,
3432 offset_type *types_list_elements)
3434 const gdb_byte *addr;
3435 offset_type version;
3436 offset_type *metadata;
3439 if (dwarf2_section_empty_p (section))
3442 /* Older elfutils strip versions could keep the section in the main
3443 executable while splitting it for the separate debug info file. */
3444 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
3447 dwarf2_read_section (objfile, section);
3449 addr = section->buffer;
3450 /* Version check. */
3451 version = MAYBE_SWAP (*(offset_type *) addr);
3452 /* Versions earlier than 3 emitted every copy of a psymbol. This
3453 causes the index to behave very poorly for certain requests. Version 3
3454 contained incomplete addrmap. So, it seems better to just ignore such
3458 static int warning_printed = 0;
3459 if (!warning_printed)
3461 warning (_("Skipping obsolete .gdb_index section in %s."),
3463 warning_printed = 1;
3467 /* Index version 4 uses a different hash function than index version
3470 Versions earlier than 6 did not emit psymbols for inlined
3471 functions. Using these files will cause GDB not to be able to
3472 set breakpoints on inlined functions by name, so we ignore these
3473 indices unless the user has done
3474 "set use-deprecated-index-sections on". */
3475 if (version < 6 && !deprecated_ok)
3477 static int warning_printed = 0;
3478 if (!warning_printed)
3481 Skipping deprecated .gdb_index section in %s.\n\
3482 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3483 to use the section anyway."),
3485 warning_printed = 1;
3489 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3490 of the TU (for symbols coming from TUs),
3491 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3492 Plus gold-generated indices can have duplicate entries for global symbols,
3493 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3494 These are just performance bugs, and we can't distinguish gdb-generated
3495 indices from gold-generated ones, so issue no warning here. */
3497 /* Indexes with higher version than the one supported by GDB may be no
3498 longer backward compatible. */
3502 map->version = version;
3504 metadata = (offset_type *) (addr + sizeof (offset_type));
3507 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3508 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3512 *types_list = addr + MAYBE_SWAP (metadata[i]);
3513 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3514 - MAYBE_SWAP (metadata[i]))
3518 const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3519 const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3521 = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3524 const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3525 const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3527 = gdb::array_view<mapped_index::symbol_table_slot>
3528 ((mapped_index::symbol_table_slot *) symbol_table,
3529 (mapped_index::symbol_table_slot *) symbol_table_end);
3532 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3537 /* Read .gdb_index. If everything went ok, initialize the "quick"
3538 elements of all the CUs and return 1. Otherwise, return 0. */
3541 dwarf2_read_index (struct dwarf2_per_objfile *dwarf2_per_objfile)
3543 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3544 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3545 struct dwz_file *dwz;
3546 struct objfile *objfile = dwarf2_per_objfile->objfile;
3548 std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3549 if (!read_index_from_section (objfile, objfile_name (objfile),
3550 use_deprecated_index_sections,
3551 &dwarf2_per_objfile->gdb_index, map.get (),
3552 &cu_list, &cu_list_elements,
3553 &types_list, &types_list_elements))
3556 /* Don't use the index if it's empty. */
3557 if (map->symbol_table.empty ())
3560 /* If there is a .dwz file, read it so we can get its CU list as
3562 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3565 struct mapped_index dwz_map;
3566 const gdb_byte *dwz_types_ignore;
3567 offset_type dwz_types_elements_ignore;
3569 if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
3571 &dwz->gdb_index, &dwz_map,
3572 &dwz_list, &dwz_list_elements,
3574 &dwz_types_elements_ignore))
3576 warning (_("could not read '.gdb_index' section from %s; skipping"),
3577 bfd_get_filename (dwz->dwz_bfd));
3582 create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3583 dwz_list, dwz_list_elements);
3585 if (types_list_elements)
3587 struct dwarf2_section_info *section;
3589 /* We can only handle a single .debug_types when we have an
3591 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3594 section = VEC_index (dwarf2_section_info_def,
3595 dwarf2_per_objfile->types, 0);
3597 create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3598 types_list, types_list_elements);
3601 create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3603 dwarf2_per_objfile->index_table = std::move (map);
3604 dwarf2_per_objfile->using_index = 1;
3605 dwarf2_per_objfile->quick_file_names_table =
3606 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3611 /* die_reader_func for dw2_get_file_names. */
3614 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3615 const gdb_byte *info_ptr,
3616 struct die_info *comp_unit_die,
3620 struct dwarf2_cu *cu = reader->cu;
3621 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3622 struct dwarf2_per_objfile *dwarf2_per_objfile
3623 = cu->per_cu->dwarf2_per_objfile;
3624 struct objfile *objfile = dwarf2_per_objfile->objfile;
3625 struct dwarf2_per_cu_data *lh_cu;
3626 struct attribute *attr;
3629 struct quick_file_names *qfn;
3631 gdb_assert (! this_cu->is_debug_types);
3633 /* Our callers never want to match partial units -- instead they
3634 will match the enclosing full CU. */
3635 if (comp_unit_die->tag == DW_TAG_partial_unit)
3637 this_cu->v.quick->no_file_data = 1;
3645 sect_offset line_offset {};
3647 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3650 struct quick_file_names find_entry;
3652 line_offset = (sect_offset) DW_UNSND (attr);
3654 /* We may have already read in this line header (TU line header sharing).
3655 If we have we're done. */
3656 find_entry.hash.dwo_unit = cu->dwo_unit;
3657 find_entry.hash.line_sect_off = line_offset;
3658 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3659 &find_entry, INSERT);
3662 lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3666 lh = dwarf_decode_line_header (line_offset, cu);
3670 lh_cu->v.quick->no_file_data = 1;
3674 qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3675 qfn->hash.dwo_unit = cu->dwo_unit;
3676 qfn->hash.line_sect_off = line_offset;
3677 gdb_assert (slot != NULL);
3680 file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3682 qfn->num_file_names = lh->file_names.size ();
3684 XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3685 for (i = 0; i < lh->file_names.size (); ++i)
3686 qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3687 qfn->real_names = NULL;
3689 lh_cu->v.quick->file_names = qfn;
3692 /* A helper for the "quick" functions which attempts to read the line
3693 table for THIS_CU. */
3695 static struct quick_file_names *
3696 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3698 /* This should never be called for TUs. */
3699 gdb_assert (! this_cu->is_debug_types);
3700 /* Nor type unit groups. */
3701 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3703 if (this_cu->v.quick->file_names != NULL)
3704 return this_cu->v.quick->file_names;
3705 /* If we know there is no line data, no point in looking again. */
3706 if (this_cu->v.quick->no_file_data)
3709 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3711 if (this_cu->v.quick->no_file_data)
3713 return this_cu->v.quick->file_names;
3716 /* A helper for the "quick" functions which computes and caches the
3717 real path for a given file name from the line table. */
3720 dw2_get_real_path (struct objfile *objfile,
3721 struct quick_file_names *qfn, int index)
3723 if (qfn->real_names == NULL)
3724 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3725 qfn->num_file_names, const char *);
3727 if (qfn->real_names[index] == NULL)
3728 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3730 return qfn->real_names[index];
3733 static struct symtab *
3734 dw2_find_last_source_symtab (struct objfile *objfile)
3736 struct dwarf2_per_objfile *dwarf2_per_objfile
3737 = get_dwarf2_per_objfile (objfile);
3738 dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3739 compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3744 return compunit_primary_filetab (cust);
3747 /* Traversal function for dw2_forget_cached_source_info. */
3750 dw2_free_cached_file_names (void **slot, void *info)
3752 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3754 if (file_data->real_names)
3758 for (i = 0; i < file_data->num_file_names; ++i)
3760 xfree ((void*) file_data->real_names[i]);
3761 file_data->real_names[i] = NULL;
3769 dw2_forget_cached_source_info (struct objfile *objfile)
3771 struct dwarf2_per_objfile *dwarf2_per_objfile
3772 = get_dwarf2_per_objfile (objfile);
3774 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3775 dw2_free_cached_file_names, NULL);
3778 /* Helper function for dw2_map_symtabs_matching_filename that expands
3779 the symtabs and calls the iterator. */
3782 dw2_map_expand_apply (struct objfile *objfile,
3783 struct dwarf2_per_cu_data *per_cu,
3784 const char *name, const char *real_path,
3785 gdb::function_view<bool (symtab *)> callback)
3787 struct compunit_symtab *last_made = objfile->compunit_symtabs;
3789 /* Don't visit already-expanded CUs. */
3790 if (per_cu->v.quick->compunit_symtab)
3793 /* This may expand more than one symtab, and we want to iterate over
3795 dw2_instantiate_symtab (per_cu, false);
3797 return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3798 last_made, callback);
3801 /* Implementation of the map_symtabs_matching_filename method. */
3804 dw2_map_symtabs_matching_filename
3805 (struct objfile *objfile, const char *name, const char *real_path,
3806 gdb::function_view<bool (symtab *)> callback)
3808 const char *name_basename = lbasename (name);
3809 struct dwarf2_per_objfile *dwarf2_per_objfile
3810 = get_dwarf2_per_objfile (objfile);
3812 /* The rule is CUs specify all the files, including those used by
3813 any TU, so there's no need to scan TUs here. */
3815 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3817 /* We only need to look at symtabs not already expanded. */
3818 if (per_cu->v.quick->compunit_symtab)
3821 quick_file_names *file_data = dw2_get_file_names (per_cu);
3822 if (file_data == NULL)
3825 for (int j = 0; j < file_data->num_file_names; ++j)
3827 const char *this_name = file_data->file_names[j];
3828 const char *this_real_name;
3830 if (compare_filenames_for_search (this_name, name))
3832 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3838 /* Before we invoke realpath, which can get expensive when many
3839 files are involved, do a quick comparison of the basenames. */
3840 if (! basenames_may_differ
3841 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3844 this_real_name = dw2_get_real_path (objfile, file_data, j);
3845 if (compare_filenames_for_search (this_real_name, name))
3847 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3853 if (real_path != NULL)
3855 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3856 gdb_assert (IS_ABSOLUTE_PATH (name));
3857 if (this_real_name != NULL
3858 && FILENAME_CMP (real_path, this_real_name) == 0)
3860 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3872 /* Struct used to manage iterating over all CUs looking for a symbol. */
3874 struct dw2_symtab_iterator
3876 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3877 struct dwarf2_per_objfile *dwarf2_per_objfile;
3878 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3879 int want_specific_block;
3880 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3881 Unused if !WANT_SPECIFIC_BLOCK. */
3883 /* The kind of symbol we're looking for. */
3885 /* The list of CUs from the index entry of the symbol,
3886 or NULL if not found. */
3888 /* The next element in VEC to look at. */
3890 /* The number of elements in VEC, or zero if there is no match. */
3892 /* Have we seen a global version of the symbol?
3893 If so we can ignore all further global instances.
3894 This is to work around gold/15646, inefficient gold-generated
3899 /* Initialize the index symtab iterator ITER.
3900 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3901 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3904 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3905 struct dwarf2_per_objfile *dwarf2_per_objfile,
3906 int want_specific_block,
3911 iter->dwarf2_per_objfile = dwarf2_per_objfile;
3912 iter->want_specific_block = want_specific_block;
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 int want_static = iter->block_index != GLOBAL_BLOCK;
3943 /* This value is only valid for index versions >= 7. */
3944 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3945 gdb_index_symbol_kind symbol_kind =
3946 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3947 /* Only check the symbol attributes if they're present.
3948 Indices prior to version 7 don't record them,
3949 and indices >= 7 may elide them for certain symbols
3950 (gold does this). */
3952 (dwarf2_per_objfile->index_table->version >= 7
3953 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3955 /* Don't crash on bad data. */
3956 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
3957 + dwarf2_per_objfile->all_type_units.size ()))
3959 complaint (&symfile_complaints,
3960 _(".gdb_index entry has bad CU index"
3962 objfile_name (dwarf2_per_objfile->objfile));
3966 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
3968 /* Skip if already read in. */
3969 if (per_cu->v.quick->compunit_symtab)
3972 /* Check static vs global. */
3975 if (iter->want_specific_block
3976 && want_static != is_static)
3978 /* Work around gold/15646. */
3979 if (!is_static && iter->global_seen)
3982 iter->global_seen = 1;
3985 /* Only check the symbol's kind if it has one. */
3988 switch (iter->domain)
3991 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
3992 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
3993 /* Some types are also in VAR_DOMAIN. */
3994 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3998 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4002 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4017 static struct compunit_symtab *
4018 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4019 const char *name, domain_enum domain)
4021 struct compunit_symtab *stab_best = NULL;
4022 struct dwarf2_per_objfile *dwarf2_per_objfile
4023 = get_dwarf2_per_objfile (objfile);
4025 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4027 struct dw2_symtab_iterator iter;
4028 struct dwarf2_per_cu_data *per_cu;
4030 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4032 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4034 struct symbol *sym, *with_opaque = NULL;
4035 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4036 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4037 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4039 sym = block_find_symbol (block, name, domain,
4040 block_find_non_opaque_type_preferred,
4043 /* Some caution must be observed with overloaded functions
4044 and methods, since the index will not contain any overload
4045 information (but NAME might contain it). */
4048 && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4050 if (with_opaque != NULL
4051 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4054 /* Keep looking through other CUs. */
4061 dw2_print_stats (struct objfile *objfile)
4063 struct dwarf2_per_objfile *dwarf2_per_objfile
4064 = get_dwarf2_per_objfile (objfile);
4065 int total = (dwarf2_per_objfile->all_comp_units.size ()
4066 + dwarf2_per_objfile->all_type_units.size ());
4069 for (int i = 0; i < total; ++i)
4071 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4073 if (!per_cu->v.quick->compunit_symtab)
4076 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
4077 printf_filtered (_(" Number of unread CUs: %d\n"), count);
4080 /* This dumps minimal information about the index.
4081 It is called via "mt print objfiles".
4082 One use is to verify .gdb_index has been loaded by the
4083 gdb.dwarf2/gdb-index.exp testcase. */
4086 dw2_dump (struct objfile *objfile)
4088 struct dwarf2_per_objfile *dwarf2_per_objfile
4089 = get_dwarf2_per_objfile (objfile);
4091 gdb_assert (dwarf2_per_objfile->using_index);
4092 printf_filtered (".gdb_index:");
4093 if (dwarf2_per_objfile->index_table != NULL)
4095 printf_filtered (" version %d\n",
4096 dwarf2_per_objfile->index_table->version);
4099 printf_filtered (" faked for \"readnow\"\n");
4100 printf_filtered ("\n");
4104 dw2_relocate (struct objfile *objfile,
4105 const struct section_offsets *new_offsets,
4106 const struct section_offsets *delta)
4108 /* There's nothing to relocate here. */
4112 dw2_expand_symtabs_for_function (struct objfile *objfile,
4113 const char *func_name)
4115 struct dwarf2_per_objfile *dwarf2_per_objfile
4116 = get_dwarf2_per_objfile (objfile);
4118 struct dw2_symtab_iterator iter;
4119 struct dwarf2_per_cu_data *per_cu;
4121 /* Note: It doesn't matter what we pass for block_index here. */
4122 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4125 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4126 dw2_instantiate_symtab (per_cu, false);
4131 dw2_expand_all_symtabs (struct objfile *objfile)
4133 struct dwarf2_per_objfile *dwarf2_per_objfile
4134 = get_dwarf2_per_objfile (objfile);
4135 int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4136 + dwarf2_per_objfile->all_type_units.size ());
4138 for (int i = 0; i < total_units; ++i)
4140 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4142 /* We don't want to directly expand a partial CU, because if we
4143 read it with the wrong language, then assertion failures can
4144 be triggered later on. See PR symtab/23010. So, tell
4145 dw2_instantiate_symtab to skip partial CUs -- any important
4146 partial CU will be read via DW_TAG_imported_unit anyway. */
4147 dw2_instantiate_symtab (per_cu, true);
4152 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4153 const char *fullname)
4155 struct dwarf2_per_objfile *dwarf2_per_objfile
4156 = get_dwarf2_per_objfile (objfile);
4158 /* We don't need to consider type units here.
4159 This is only called for examining code, e.g. expand_line_sal.
4160 There can be an order of magnitude (or more) more type units
4161 than comp units, and we avoid them if we can. */
4163 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4165 /* We only need to look at symtabs not already expanded. */
4166 if (per_cu->v.quick->compunit_symtab)
4169 quick_file_names *file_data = dw2_get_file_names (per_cu);
4170 if (file_data == NULL)
4173 for (int j = 0; j < file_data->num_file_names; ++j)
4175 const char *this_fullname = file_data->file_names[j];
4177 if (filename_cmp (this_fullname, fullname) == 0)
4179 dw2_instantiate_symtab (per_cu, false);
4187 dw2_map_matching_symbols (struct objfile *objfile,
4188 const char * name, domain_enum domain,
4190 int (*callback) (struct block *,
4191 struct symbol *, void *),
4192 void *data, symbol_name_match_type match,
4193 symbol_compare_ftype *ordered_compare)
4195 /* Currently unimplemented; used for Ada. The function can be called if the
4196 current language is Ada for a non-Ada objfile using GNU index. As Ada
4197 does not look for non-Ada symbols this function should just return. */
4200 /* Symbol name matcher for .gdb_index names.
4202 Symbol names in .gdb_index have a few particularities:
4204 - There's no indication of which is the language of each symbol.
4206 Since each language has its own symbol name matching algorithm,
4207 and we don't know which language is the right one, we must match
4208 each symbol against all languages. This would be a potential
4209 performance problem if it were not mitigated by the
4210 mapped_index::name_components lookup table, which significantly
4211 reduces the number of times we need to call into this matcher,
4212 making it a non-issue.
4214 - Symbol names in the index have no overload (parameter)
4215 information. I.e., in C++, "foo(int)" and "foo(long)" both
4216 appear as "foo" in the index, for example.
4218 This means that the lookup names passed to the symbol name
4219 matcher functions must have no parameter information either
4220 because (e.g.) symbol search name "foo" does not match
4221 lookup-name "foo(int)" [while swapping search name for lookup
4224 class gdb_index_symbol_name_matcher
4227 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4228 gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4230 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4231 Returns true if any matcher matches. */
4232 bool matches (const char *symbol_name);
4235 /* A reference to the lookup name we're matching against. */
4236 const lookup_name_info &m_lookup_name;
4238 /* A vector holding all the different symbol name matchers, for all
4240 std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4243 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4244 (const lookup_name_info &lookup_name)
4245 : m_lookup_name (lookup_name)
4247 /* Prepare the vector of comparison functions upfront, to avoid
4248 doing the same work for each symbol. Care is taken to avoid
4249 matching with the same matcher more than once if/when multiple
4250 languages use the same matcher function. */
4251 auto &matchers = m_symbol_name_matcher_funcs;
4252 matchers.reserve (nr_languages);
4254 matchers.push_back (default_symbol_name_matcher);
4256 for (int i = 0; i < nr_languages; i++)
4258 const language_defn *lang = language_def ((enum language) i);
4259 symbol_name_matcher_ftype *name_matcher
4260 = get_symbol_name_matcher (lang, m_lookup_name);
4262 /* Don't insert the same comparison routine more than once.
4263 Note that we do this linear walk instead of a seemingly
4264 cheaper sorted insert, or use a std::set or something like
4265 that, because relative order of function addresses is not
4266 stable. This is not a problem in practice because the number
4267 of supported languages is low, and the cost here is tiny
4268 compared to the number of searches we'll do afterwards using
4270 if (name_matcher != default_symbol_name_matcher
4271 && (std::find (matchers.begin (), matchers.end (), name_matcher)
4272 == matchers.end ()))
4273 matchers.push_back (name_matcher);
4278 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4280 for (auto matches_name : m_symbol_name_matcher_funcs)
4281 if (matches_name (symbol_name, m_lookup_name, NULL))
4287 /* Starting from a search name, return the string that finds the upper
4288 bound of all strings that start with SEARCH_NAME in a sorted name
4289 list. Returns the empty string to indicate that the upper bound is
4290 the end of the list. */
4293 make_sort_after_prefix_name (const char *search_name)
4295 /* When looking to complete "func", we find the upper bound of all
4296 symbols that start with "func" by looking for where we'd insert
4297 the closest string that would follow "func" in lexicographical
4298 order. Usually, that's "func"-with-last-character-incremented,
4299 i.e. "fund". Mind non-ASCII characters, though. Usually those
4300 will be UTF-8 multi-byte sequences, but we can't be certain.
4301 Especially mind the 0xff character, which is a valid character in
4302 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4303 rule out compilers allowing it in identifiers. Note that
4304 conveniently, strcmp/strcasecmp are specified to compare
4305 characters interpreted as unsigned char. So what we do is treat
4306 the whole string as a base 256 number composed of a sequence of
4307 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4308 to 0, and carries 1 to the following more-significant position.
4309 If the very first character in SEARCH_NAME ends up incremented
4310 and carries/overflows, then the upper bound is the end of the
4311 list. The string after the empty string is also the empty
4314 Some examples of this operation:
4316 SEARCH_NAME => "+1" RESULT
4320 "\xff" "a" "\xff" => "\xff" "b"
4325 Then, with these symbols for example:
4331 completing "func" looks for symbols between "func" and
4332 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4333 which finds "func" and "func1", but not "fund".
4337 funcÿ (Latin1 'ÿ' [0xff])
4341 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4342 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4346 ÿÿ (Latin1 'ÿ' [0xff])
4349 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4350 the end of the list.
4352 std::string after = search_name;
4353 while (!after.empty () && (unsigned char) after.back () == 0xff)
4355 if (!after.empty ())
4356 after.back () = (unsigned char) after.back () + 1;
4360 /* See declaration. */
4362 std::pair<std::vector<name_component>::const_iterator,
4363 std::vector<name_component>::const_iterator>
4364 mapped_index_base::find_name_components_bounds
4365 (const lookup_name_info &lookup_name_without_params) const
4368 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4371 = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4373 /* Comparison function object for lower_bound that matches against a
4374 given symbol name. */
4375 auto lookup_compare_lower = [&] (const name_component &elem,
4378 const char *elem_qualified = this->symbol_name_at (elem.idx);
4379 const char *elem_name = elem_qualified + elem.name_offset;
4380 return name_cmp (elem_name, name) < 0;
4383 /* Comparison function object for upper_bound that matches against a
4384 given symbol name. */
4385 auto lookup_compare_upper = [&] (const char *name,
4386 const name_component &elem)
4388 const char *elem_qualified = this->symbol_name_at (elem.idx);
4389 const char *elem_name = elem_qualified + elem.name_offset;
4390 return name_cmp (name, elem_name) < 0;
4393 auto begin = this->name_components.begin ();
4394 auto end = this->name_components.end ();
4396 /* Find the lower bound. */
4399 if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4402 return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4405 /* Find the upper bound. */
4408 if (lookup_name_without_params.completion_mode ())
4410 /* In completion mode, we want UPPER to point past all
4411 symbols names that have the same prefix. I.e., with
4412 these symbols, and completing "func":
4414 function << lower bound
4416 other_function << upper bound
4418 We find the upper bound by looking for the insertion
4419 point of "func"-with-last-character-incremented,
4421 std::string after = make_sort_after_prefix_name (cplus);
4424 return std::lower_bound (lower, end, after.c_str (),
4425 lookup_compare_lower);
4428 return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4431 return {lower, upper};
4434 /* See declaration. */
4437 mapped_index_base::build_name_components ()
4439 if (!this->name_components.empty ())
4442 this->name_components_casing = case_sensitivity;
4444 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4446 /* The code below only knows how to break apart components of C++
4447 symbol names (and other languages that use '::' as
4448 namespace/module separator). If we add support for wild matching
4449 to some language that uses some other operator (E.g., Ada, Go and
4450 D use '.'), then we'll need to try splitting the symbol name
4451 according to that language too. Note that Ada does support wild
4452 matching, but doesn't currently support .gdb_index. */
4453 auto count = this->symbol_name_count ();
4454 for (offset_type idx = 0; idx < count; idx++)
4456 if (this->symbol_name_slot_invalid (idx))
4459 const char *name = this->symbol_name_at (idx);
4461 /* Add each name component to the name component table. */
4462 unsigned int previous_len = 0;
4463 for (unsigned int current_len = cp_find_first_component (name);
4464 name[current_len] != '\0';
4465 current_len += cp_find_first_component (name + current_len))
4467 gdb_assert (name[current_len] == ':');
4468 this->name_components.push_back ({previous_len, idx});
4469 /* Skip the '::'. */
4471 previous_len = current_len;
4473 this->name_components.push_back ({previous_len, idx});
4476 /* Sort name_components elements by name. */
4477 auto name_comp_compare = [&] (const name_component &left,
4478 const name_component &right)
4480 const char *left_qualified = this->symbol_name_at (left.idx);
4481 const char *right_qualified = this->symbol_name_at (right.idx);
4483 const char *left_name = left_qualified + left.name_offset;
4484 const char *right_name = right_qualified + right.name_offset;
4486 return name_cmp (left_name, right_name) < 0;
4489 std::sort (this->name_components.begin (),
4490 this->name_components.end (),
4494 /* Helper for dw2_expand_symtabs_matching that works with a
4495 mapped_index_base instead of the containing objfile. This is split
4496 to a separate function in order to be able to unit test the
4497 name_components matching using a mock mapped_index_base. For each
4498 symbol name that matches, calls MATCH_CALLBACK, passing it the
4499 symbol's index in the mapped_index_base symbol table. */
4502 dw2_expand_symtabs_matching_symbol
4503 (mapped_index_base &index,
4504 const lookup_name_info &lookup_name_in,
4505 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4506 enum search_domain kind,
4507 gdb::function_view<void (offset_type)> match_callback)
4509 lookup_name_info lookup_name_without_params
4510 = lookup_name_in.make_ignore_params ();
4511 gdb_index_symbol_name_matcher lookup_name_matcher
4512 (lookup_name_without_params);
4514 /* Build the symbol name component sorted vector, if we haven't
4516 index.build_name_components ();
4518 auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4520 /* Now for each symbol name in range, check to see if we have a name
4521 match, and if so, call the MATCH_CALLBACK callback. */
4523 /* The same symbol may appear more than once in the range though.
4524 E.g., if we're looking for symbols that complete "w", and we have
4525 a symbol named "w1::w2", we'll find the two name components for
4526 that same symbol in the range. To be sure we only call the
4527 callback once per symbol, we first collect the symbol name
4528 indexes that matched in a temporary vector and ignore
4530 std::vector<offset_type> matches;
4531 matches.reserve (std::distance (bounds.first, bounds.second));
4533 for (; bounds.first != bounds.second; ++bounds.first)
4535 const char *qualified = index.symbol_name_at (bounds.first->idx);
4537 if (!lookup_name_matcher.matches (qualified)
4538 || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4541 matches.push_back (bounds.first->idx);
4544 std::sort (matches.begin (), matches.end ());
4546 /* Finally call the callback, once per match. */
4548 for (offset_type idx : matches)
4552 match_callback (idx);
4557 /* Above we use a type wider than idx's for 'prev', since 0 and
4558 (offset_type)-1 are both possible values. */
4559 static_assert (sizeof (prev) > sizeof (offset_type), "");
4564 namespace selftests { namespace dw2_expand_symtabs_matching {
4566 /* A mock .gdb_index/.debug_names-like name index table, enough to
4567 exercise dw2_expand_symtabs_matching_symbol, which works with the
4568 mapped_index_base interface. Builds an index from the symbol list
4569 passed as parameter to the constructor. */
4570 class mock_mapped_index : public mapped_index_base
4573 mock_mapped_index (gdb::array_view<const char *> symbols)
4574 : m_symbol_table (symbols)
4577 DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4579 /* Return the number of names in the symbol table. */
4580 size_t symbol_name_count () const override
4582 return m_symbol_table.size ();
4585 /* Get the name of the symbol at IDX in the symbol table. */
4586 const char *symbol_name_at (offset_type idx) const override
4588 return m_symbol_table[idx];
4592 gdb::array_view<const char *> m_symbol_table;
4595 /* Convenience function that converts a NULL pointer to a "<null>"
4596 string, to pass to print routines. */
4599 string_or_null (const char *str)
4601 return str != NULL ? str : "<null>";
4604 /* Check if a lookup_name_info built from
4605 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4606 index. EXPECTED_LIST is the list of expected matches, in expected
4607 matching order. If no match expected, then an empty list is
4608 specified. Returns true on success. On failure prints a warning
4609 indicating the file:line that failed, and returns false. */
4612 check_match (const char *file, int line,
4613 mock_mapped_index &mock_index,
4614 const char *name, symbol_name_match_type match_type,
4615 bool completion_mode,
4616 std::initializer_list<const char *> expected_list)
4618 lookup_name_info lookup_name (name, match_type, completion_mode);
4620 bool matched = true;
4622 auto mismatch = [&] (const char *expected_str,
4625 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4626 "expected=\"%s\", got=\"%s\"\n"),
4628 (match_type == symbol_name_match_type::FULL
4630 name, string_or_null (expected_str), string_or_null (got));
4634 auto expected_it = expected_list.begin ();
4635 auto expected_end = expected_list.end ();
4637 dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4639 [&] (offset_type idx)
4641 const char *matched_name = mock_index.symbol_name_at (idx);
4642 const char *expected_str
4643 = expected_it == expected_end ? NULL : *expected_it++;
4645 if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4646 mismatch (expected_str, matched_name);
4649 const char *expected_str
4650 = expected_it == expected_end ? NULL : *expected_it++;
4651 if (expected_str != NULL)
4652 mismatch (expected_str, NULL);
4657 /* The symbols added to the mock mapped_index for testing (in
4659 static const char *test_symbols[] = {
4668 "ns2::tmpl<int>::foo2",
4669 "(anonymous namespace)::A::B::C",
4671 /* These are used to check that the increment-last-char in the
4672 matching algorithm for completion doesn't match "t1_fund" when
4673 completing "t1_func". */
4679 /* A UTF-8 name with multi-byte sequences to make sure that
4680 cp-name-parser understands this as a single identifier ("função"
4681 is "function" in PT). */
4684 /* \377 (0xff) is Latin1 'ÿ'. */
4687 /* \377 (0xff) is Latin1 'ÿ'. */
4691 /* A name with all sorts of complications. Starts with "z" to make
4692 it easier for the completion tests below. */
4693 #define Z_SYM_NAME \
4694 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4695 "::tuple<(anonymous namespace)::ui*, " \
4696 "std::default_delete<(anonymous namespace)::ui>, void>"
4701 /* Returns true if the mapped_index_base::find_name_component_bounds
4702 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4703 in completion mode. */
4706 check_find_bounds_finds (mapped_index_base &index,
4707 const char *search_name,
4708 gdb::array_view<const char *> expected_syms)
4710 lookup_name_info lookup_name (search_name,
4711 symbol_name_match_type::FULL, true);
4713 auto bounds = index.find_name_components_bounds (lookup_name);
4715 size_t distance = std::distance (bounds.first, bounds.second);
4716 if (distance != expected_syms.size ())
4719 for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4721 auto nc_elem = bounds.first + exp_elem;
4722 const char *qualified = index.symbol_name_at (nc_elem->idx);
4723 if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4730 /* Test the lower-level mapped_index::find_name_component_bounds
4734 test_mapped_index_find_name_component_bounds ()
4736 mock_mapped_index mock_index (test_symbols);
4738 mock_index.build_name_components ();
4740 /* Test the lower-level mapped_index::find_name_component_bounds
4741 method in completion mode. */
4743 static const char *expected_syms[] = {
4748 SELF_CHECK (check_find_bounds_finds (mock_index,
4749 "t1_func", expected_syms));
4752 /* Check that the increment-last-char in the name matching algorithm
4753 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4755 static const char *expected_syms1[] = {
4759 SELF_CHECK (check_find_bounds_finds (mock_index,
4760 "\377", expected_syms1));
4762 static const char *expected_syms2[] = {
4765 SELF_CHECK (check_find_bounds_finds (mock_index,
4766 "\377\377", expected_syms2));
4770 /* Test dw2_expand_symtabs_matching_symbol. */
4773 test_dw2_expand_symtabs_matching_symbol ()
4775 mock_mapped_index mock_index (test_symbols);
4777 /* We let all tests run until the end even if some fails, for debug
4779 bool any_mismatch = false;
4781 /* Create the expected symbols list (an initializer_list). Needed
4782 because lists have commas, and we need to pass them to CHECK,
4783 which is a macro. */
4784 #define EXPECT(...) { __VA_ARGS__ }
4786 /* Wrapper for check_match that passes down the current
4787 __FILE__/__LINE__. */
4788 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4789 any_mismatch |= !check_match (__FILE__, __LINE__, \
4791 NAME, MATCH_TYPE, COMPLETION_MODE, \
4794 /* Identity checks. */
4795 for (const char *sym : test_symbols)
4797 /* Should be able to match all existing symbols. */
4798 CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4801 /* Should be able to match all existing symbols with
4803 std::string with_params = std::string (sym) + "(int)";
4804 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4807 /* Should be able to match all existing symbols with
4808 parameters and qualifiers. */
4809 with_params = std::string (sym) + " ( int ) const";
4810 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4813 /* This should really find sym, but cp-name-parser.y doesn't
4814 know about lvalue/rvalue qualifiers yet. */
4815 with_params = std::string (sym) + " ( int ) &&";
4816 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4820 /* Check that the name matching algorithm for completion doesn't get
4821 confused with Latin1 'ÿ' / 0xff. */
4823 static const char str[] = "\377";
4824 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4825 EXPECT ("\377", "\377\377123"));
4828 /* Check that the increment-last-char in the matching algorithm for
4829 completion doesn't match "t1_fund" when completing "t1_func". */
4831 static const char str[] = "t1_func";
4832 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4833 EXPECT ("t1_func", "t1_func1"));
4836 /* Check that completion mode works at each prefix of the expected
4839 static const char str[] = "function(int)";
4840 size_t len = strlen (str);
4843 for (size_t i = 1; i < len; i++)
4845 lookup.assign (str, i);
4846 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4847 EXPECT ("function"));
4851 /* While "w" is a prefix of both components, the match function
4852 should still only be called once. */
4854 CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4856 CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4860 /* Same, with a "complicated" symbol. */
4862 static const char str[] = Z_SYM_NAME;
4863 size_t len = strlen (str);
4866 for (size_t i = 1; i < len; i++)
4868 lookup.assign (str, i);
4869 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4870 EXPECT (Z_SYM_NAME));
4874 /* In FULL mode, an incomplete symbol doesn't match. */
4876 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4880 /* A complete symbol with parameters matches any overload, since the
4881 index has no overload info. */
4883 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4884 EXPECT ("std::zfunction", "std::zfunction2"));
4885 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4886 EXPECT ("std::zfunction", "std::zfunction2"));
4887 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4888 EXPECT ("std::zfunction", "std::zfunction2"));
4891 /* Check that whitespace is ignored appropriately. A symbol with a
4892 template argument list. */
4894 static const char expected[] = "ns::foo<int>";
4895 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4897 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4901 /* Check that whitespace is ignored appropriately. A symbol with a
4902 template argument list that includes a pointer. */
4904 static const char expected[] = "ns::foo<char*>";
4905 /* Try both completion and non-completion modes. */
4906 static const bool completion_mode[2] = {false, true};
4907 for (size_t i = 0; i < 2; i++)
4909 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4910 completion_mode[i], EXPECT (expected));
4911 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4912 completion_mode[i], EXPECT (expected));
4914 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4915 completion_mode[i], EXPECT (expected));
4916 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4917 completion_mode[i], EXPECT (expected));
4922 /* Check method qualifiers are ignored. */
4923 static const char expected[] = "ns::foo<char*>";
4924 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4925 symbol_name_match_type::FULL, true, EXPECT (expected));
4926 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4927 symbol_name_match_type::FULL, true, EXPECT (expected));
4928 CHECK_MATCH ("foo < char * > ( int ) const",
4929 symbol_name_match_type::WILD, true, EXPECT (expected));
4930 CHECK_MATCH ("foo < char * > ( int ) &&",
4931 symbol_name_match_type::WILD, true, EXPECT (expected));
4934 /* Test lookup names that don't match anything. */
4936 CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4939 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4943 /* Some wild matching tests, exercising "(anonymous namespace)",
4944 which should not be confused with a parameter list. */
4946 static const char *syms[] = {
4950 "A :: B :: C ( int )",
4955 for (const char *s : syms)
4957 CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4958 EXPECT ("(anonymous namespace)::A::B::C"));
4963 static const char expected[] = "ns2::tmpl<int>::foo2";
4964 CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
4966 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
4970 SELF_CHECK (!any_mismatch);
4979 test_mapped_index_find_name_component_bounds ();
4980 test_dw2_expand_symtabs_matching_symbol ();
4983 }} // namespace selftests::dw2_expand_symtabs_matching
4985 #endif /* GDB_SELF_TEST */
4987 /* If FILE_MATCHER is NULL or if PER_CU has
4988 dwarf2_per_cu_quick_data::MARK set (see
4989 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4990 EXPANSION_NOTIFY on it. */
4993 dw2_expand_symtabs_matching_one
4994 (struct dwarf2_per_cu_data *per_cu,
4995 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
4996 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
4998 if (file_matcher == NULL || per_cu->v.quick->mark)
5000 bool symtab_was_null
5001 = (per_cu->v.quick->compunit_symtab == NULL);
5003 dw2_instantiate_symtab (per_cu, false);
5005 if (expansion_notify != NULL
5007 && per_cu->v.quick->compunit_symtab != NULL)
5008 expansion_notify (per_cu->v.quick->compunit_symtab);
5012 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5013 matched, to expand corresponding CUs that were marked. IDX is the
5014 index of the symbol name that matched. */
5017 dw2_expand_marked_cus
5018 (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5019 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5020 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5023 offset_type *vec, vec_len, vec_idx;
5024 bool global_seen = false;
5025 mapped_index &index = *dwarf2_per_objfile->index_table;
5027 vec = (offset_type *) (index.constant_pool
5028 + MAYBE_SWAP (index.symbol_table[idx].vec));
5029 vec_len = MAYBE_SWAP (vec[0]);
5030 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5032 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5033 /* This value is only valid for index versions >= 7. */
5034 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5035 gdb_index_symbol_kind symbol_kind =
5036 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5037 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5038 /* Only check the symbol attributes if they're present.
5039 Indices prior to version 7 don't record them,
5040 and indices >= 7 may elide them for certain symbols
5041 (gold does this). */
5044 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5046 /* Work around gold/15646. */
5049 if (!is_static && global_seen)
5055 /* Only check the symbol's kind if it has one. */
5060 case VARIABLES_DOMAIN:
5061 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5064 case FUNCTIONS_DOMAIN:
5065 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5069 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5077 /* Don't crash on bad data. */
5078 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5079 + dwarf2_per_objfile->all_type_units.size ()))
5081 complaint (&symfile_complaints,
5082 _(".gdb_index entry has bad CU index"
5084 objfile_name (dwarf2_per_objfile->objfile));
5088 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5089 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5094 /* If FILE_MATCHER is non-NULL, set all the
5095 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5096 that match FILE_MATCHER. */
5099 dw_expand_symtabs_matching_file_matcher
5100 (struct dwarf2_per_objfile *dwarf2_per_objfile,
5101 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5103 if (file_matcher == NULL)
5106 objfile *const objfile = dwarf2_per_objfile->objfile;
5108 htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5110 NULL, xcalloc, xfree));
5111 htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5113 NULL, xcalloc, xfree));
5115 /* The rule is CUs specify all the files, including those used by
5116 any TU, so there's no need to scan TUs here. */
5118 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5122 per_cu->v.quick->mark = 0;
5124 /* We only need to look at symtabs not already expanded. */
5125 if (per_cu->v.quick->compunit_symtab)
5128 quick_file_names *file_data = dw2_get_file_names (per_cu);
5129 if (file_data == NULL)
5132 if (htab_find (visited_not_found.get (), file_data) != NULL)
5134 else if (htab_find (visited_found.get (), file_data) != NULL)
5136 per_cu->v.quick->mark = 1;
5140 for (int j = 0; j < file_data->num_file_names; ++j)
5142 const char *this_real_name;
5144 if (file_matcher (file_data->file_names[j], false))
5146 per_cu->v.quick->mark = 1;
5150 /* Before we invoke realpath, which can get expensive when many
5151 files are involved, do a quick comparison of the basenames. */
5152 if (!basenames_may_differ
5153 && !file_matcher (lbasename (file_data->file_names[j]),
5157 this_real_name = dw2_get_real_path (objfile, file_data, j);
5158 if (file_matcher (this_real_name, false))
5160 per_cu->v.quick->mark = 1;
5165 void **slot = htab_find_slot (per_cu->v.quick->mark
5166 ? visited_found.get ()
5167 : visited_not_found.get (),
5174 dw2_expand_symtabs_matching
5175 (struct objfile *objfile,
5176 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5177 const lookup_name_info &lookup_name,
5178 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5179 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5180 enum search_domain kind)
5182 struct dwarf2_per_objfile *dwarf2_per_objfile
5183 = get_dwarf2_per_objfile (objfile);
5185 /* index_table is NULL if OBJF_READNOW. */
5186 if (!dwarf2_per_objfile->index_table)
5189 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5191 mapped_index &index = *dwarf2_per_objfile->index_table;
5193 dw2_expand_symtabs_matching_symbol (index, lookup_name,
5195 kind, [&] (offset_type idx)
5197 dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5198 expansion_notify, kind);
5202 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5205 static struct compunit_symtab *
5206 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5211 if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5212 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5215 if (cust->includes == NULL)
5218 for (i = 0; cust->includes[i]; ++i)
5220 struct compunit_symtab *s = cust->includes[i];
5222 s = recursively_find_pc_sect_compunit_symtab (s, pc);
5230 static struct compunit_symtab *
5231 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5232 struct bound_minimal_symbol msymbol,
5234 struct obj_section *section,
5237 struct dwarf2_per_cu_data *data;
5238 struct compunit_symtab *result;
5240 if (!objfile->psymtabs_addrmap)
5243 data = (struct dwarf2_per_cu_data *) addrmap_find (objfile->psymtabs_addrmap,
5248 if (warn_if_readin && data->v.quick->compunit_symtab)
5249 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5250 paddress (get_objfile_arch (objfile), pc));
5253 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5256 gdb_assert (result != NULL);
5261 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5262 void *data, int need_fullname)
5264 struct dwarf2_per_objfile *dwarf2_per_objfile
5265 = get_dwarf2_per_objfile (objfile);
5267 if (!dwarf2_per_objfile->filenames_cache)
5269 dwarf2_per_objfile->filenames_cache.emplace ();
5271 htab_up visited (htab_create_alloc (10,
5272 htab_hash_pointer, htab_eq_pointer,
5273 NULL, xcalloc, xfree));
5275 /* The rule is CUs specify all the files, including those used
5276 by any TU, so there's no need to scan TUs here. We can
5277 ignore file names coming from already-expanded CUs. */
5279 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5281 if (per_cu->v.quick->compunit_symtab)
5283 void **slot = htab_find_slot (visited.get (),
5284 per_cu->v.quick->file_names,
5287 *slot = per_cu->v.quick->file_names;
5291 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5293 /* We only need to look at symtabs not already expanded. */
5294 if (per_cu->v.quick->compunit_symtab)
5297 quick_file_names *file_data = dw2_get_file_names (per_cu);
5298 if (file_data == NULL)
5301 void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5304 /* Already visited. */
5309 for (int j = 0; j < file_data->num_file_names; ++j)
5311 const char *filename = file_data->file_names[j];
5312 dwarf2_per_objfile->filenames_cache->seen (filename);
5317 dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5319 gdb::unique_xmalloc_ptr<char> this_real_name;
5322 this_real_name = gdb_realpath (filename);
5323 (*fun) (filename, this_real_name.get (), data);
5328 dw2_has_symbols (struct objfile *objfile)
5333 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5336 dw2_find_last_source_symtab,
5337 dw2_forget_cached_source_info,
5338 dw2_map_symtabs_matching_filename,
5343 dw2_expand_symtabs_for_function,
5344 dw2_expand_all_symtabs,
5345 dw2_expand_symtabs_with_fullname,
5346 dw2_map_matching_symbols,
5347 dw2_expand_symtabs_matching,
5348 dw2_find_pc_sect_compunit_symtab,
5350 dw2_map_symbol_filenames
5353 /* DWARF-5 debug_names reader. */
5355 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5356 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5358 /* A helper function that reads the .debug_names section in SECTION
5359 and fills in MAP. FILENAME is the name of the file containing the
5360 section; it is used for error reporting.
5362 Returns true if all went well, false otherwise. */
5365 read_debug_names_from_section (struct objfile *objfile,
5366 const char *filename,
5367 struct dwarf2_section_info *section,
5368 mapped_debug_names &map)
5370 if (dwarf2_section_empty_p (section))
5373 /* Older elfutils strip versions could keep the section in the main
5374 executable while splitting it for the separate debug info file. */
5375 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5378 dwarf2_read_section (objfile, section);
5380 map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5382 const gdb_byte *addr = section->buffer;
5384 bfd *const abfd = get_section_bfd_owner (section);
5386 unsigned int bytes_read;
5387 LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5390 map.dwarf5_is_dwarf64 = bytes_read != 4;
5391 map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5392 if (bytes_read + length != section->size)
5394 /* There may be multiple per-CU indices. */
5395 warning (_("Section .debug_names in %s length %s does not match "
5396 "section length %s, ignoring .debug_names."),
5397 filename, plongest (bytes_read + length),
5398 pulongest (section->size));
5402 /* The version number. */
5403 uint16_t version = read_2_bytes (abfd, addr);
5407 warning (_("Section .debug_names in %s has unsupported version %d, "
5408 "ignoring .debug_names."),
5414 uint16_t padding = read_2_bytes (abfd, addr);
5418 warning (_("Section .debug_names in %s has unsupported padding %d, "
5419 "ignoring .debug_names."),
5424 /* comp_unit_count - The number of CUs in the CU list. */
5425 map.cu_count = read_4_bytes (abfd, addr);
5428 /* local_type_unit_count - The number of TUs in the local TU
5430 map.tu_count = read_4_bytes (abfd, addr);
5433 /* foreign_type_unit_count - The number of TUs in the foreign TU
5435 uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5437 if (foreign_tu_count != 0)
5439 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5440 "ignoring .debug_names."),
5441 filename, static_cast<unsigned long> (foreign_tu_count));
5445 /* bucket_count - The number of hash buckets in the hash lookup
5447 map.bucket_count = read_4_bytes (abfd, addr);
5450 /* name_count - The number of unique names in the index. */
5451 map.name_count = read_4_bytes (abfd, addr);
5454 /* abbrev_table_size - The size in bytes of the abbreviations
5456 uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5459 /* augmentation_string_size - The size in bytes of the augmentation
5460 string. This value is rounded up to a multiple of 4. */
5461 uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5463 map.augmentation_is_gdb = ((augmentation_string_size
5464 == sizeof (dwarf5_augmentation))
5465 && memcmp (addr, dwarf5_augmentation,
5466 sizeof (dwarf5_augmentation)) == 0);
5467 augmentation_string_size += (-augmentation_string_size) & 3;
5468 addr += augmentation_string_size;
5471 map.cu_table_reordered = addr;
5472 addr += map.cu_count * map.offset_size;
5474 /* List of Local TUs */
5475 map.tu_table_reordered = addr;
5476 addr += map.tu_count * map.offset_size;
5478 /* Hash Lookup Table */
5479 map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5480 addr += map.bucket_count * 4;
5481 map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5482 addr += map.name_count * 4;
5485 map.name_table_string_offs_reordered = addr;
5486 addr += map.name_count * map.offset_size;
5487 map.name_table_entry_offs_reordered = addr;
5488 addr += map.name_count * map.offset_size;
5490 const gdb_byte *abbrev_table_start = addr;
5493 unsigned int bytes_read;
5494 const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5499 const auto insertpair
5500 = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5501 if (!insertpair.second)
5503 warning (_("Section .debug_names in %s has duplicate index %s, "
5504 "ignoring .debug_names."),
5505 filename, pulongest (index_num));
5508 mapped_debug_names::index_val &indexval = insertpair.first->second;
5509 indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5514 mapped_debug_names::index_val::attr attr;
5515 attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5517 attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5519 if (attr.form == DW_FORM_implicit_const)
5521 attr.implicit_const = read_signed_leb128 (abfd, addr,
5525 if (attr.dw_idx == 0 && attr.form == 0)
5527 indexval.attr_vec.push_back (std::move (attr));
5530 if (addr != abbrev_table_start + abbrev_table_size)
5532 warning (_("Section .debug_names in %s has abbreviation_table "
5533 "of size %zu vs. written as %u, ignoring .debug_names."),
5534 filename, addr - abbrev_table_start, abbrev_table_size);
5537 map.entry_pool = addr;
5542 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5546 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5547 const mapped_debug_names &map,
5548 dwarf2_section_info §ion,
5551 sect_offset sect_off_prev;
5552 for (uint32_t i = 0; i <= map.cu_count; ++i)
5554 sect_offset sect_off_next;
5555 if (i < map.cu_count)
5558 = (sect_offset) (extract_unsigned_integer
5559 (map.cu_table_reordered + i * map.offset_size,
5561 map.dwarf5_byte_order));
5564 sect_off_next = (sect_offset) section.size;
5567 const ULONGEST length = sect_off_next - sect_off_prev;
5568 dwarf2_per_cu_data *per_cu
5569 = create_cu_from_index_list (dwarf2_per_objfile, §ion, is_dwz,
5570 sect_off_prev, length);
5571 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5573 sect_off_prev = sect_off_next;
5577 /* Read the CU list from the mapped index, and use it to create all
5578 the CU objects for this dwarf2_per_objfile. */
5581 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5582 const mapped_debug_names &map,
5583 const mapped_debug_names &dwz_map)
5585 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5586 dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5588 create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5589 dwarf2_per_objfile->info,
5590 false /* is_dwz */);
5592 if (dwz_map.cu_count == 0)
5595 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5596 create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5600 /* Read .debug_names. If everything went ok, initialize the "quick"
5601 elements of all the CUs and return true. Otherwise, return false. */
5604 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5606 mapped_debug_names local_map (dwarf2_per_objfile);
5607 mapped_debug_names dwz_map (dwarf2_per_objfile);
5608 struct objfile *objfile = dwarf2_per_objfile->objfile;
5610 if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5611 &dwarf2_per_objfile->debug_names,
5615 /* Don't use the index if it's empty. */
5616 if (local_map.name_count == 0)
5619 /* If there is a .dwz file, read it so we can get its CU list as
5621 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5624 if (!read_debug_names_from_section (objfile,
5625 bfd_get_filename (dwz->dwz_bfd),
5626 &dwz->debug_names, dwz_map))
5628 warning (_("could not read '.debug_names' section from %s; skipping"),
5629 bfd_get_filename (dwz->dwz_bfd));
5634 create_cus_from_debug_names (dwarf2_per_objfile, local_map, dwz_map);
5636 if (local_map.tu_count != 0)
5638 /* We can only handle a single .debug_types when we have an
5640 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5643 dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5644 dwarf2_per_objfile->types, 0);
5646 create_signatured_type_table_from_debug_names
5647 (dwarf2_per_objfile, local_map, section, &dwarf2_per_objfile->abbrev);
5650 create_addrmap_from_aranges (dwarf2_per_objfile,
5651 &dwarf2_per_objfile->debug_aranges);
5653 dwarf2_per_objfile->debug_names_table.reset
5654 (new mapped_debug_names (dwarf2_per_objfile));
5655 *dwarf2_per_objfile->debug_names_table = std::move (local_map);
5656 dwarf2_per_objfile->using_index = 1;
5657 dwarf2_per_objfile->quick_file_names_table =
5658 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5663 /* Type used to manage iterating over all CUs looking for a symbol for
5666 class dw2_debug_names_iterator
5669 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5670 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
5671 dw2_debug_names_iterator (const mapped_debug_names &map,
5672 bool want_specific_block,
5673 block_enum block_index, domain_enum domain,
5675 : m_map (map), m_want_specific_block (want_specific_block),
5676 m_block_index (block_index), m_domain (domain),
5677 m_addr (find_vec_in_debug_names (map, name))
5680 dw2_debug_names_iterator (const mapped_debug_names &map,
5681 search_domain search, uint32_t namei)
5684 m_addr (find_vec_in_debug_names (map, namei))
5687 /* Return the next matching CU or NULL if there are no more. */
5688 dwarf2_per_cu_data *next ();
5691 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5693 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5696 /* The internalized form of .debug_names. */
5697 const mapped_debug_names &m_map;
5699 /* If true, only look for symbols that match BLOCK_INDEX. */
5700 const bool m_want_specific_block = false;
5702 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5703 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5705 const block_enum m_block_index = FIRST_LOCAL_BLOCK;
5707 /* The kind of symbol we're looking for. */
5708 const domain_enum m_domain = UNDEF_DOMAIN;
5709 const search_domain m_search = ALL_DOMAIN;
5711 /* The list of CUs from the index entry of the symbol, or NULL if
5713 const gdb_byte *m_addr;
5717 mapped_debug_names::namei_to_name (uint32_t namei) const
5719 const ULONGEST namei_string_offs
5720 = extract_unsigned_integer ((name_table_string_offs_reordered
5721 + namei * offset_size),
5724 return read_indirect_string_at_offset
5725 (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5728 /* Find a slot in .debug_names for the object named NAME. If NAME is
5729 found, return pointer to its pool data. If NAME cannot be found,
5733 dw2_debug_names_iterator::find_vec_in_debug_names
5734 (const mapped_debug_names &map, const char *name)
5736 int (*cmp) (const char *, const char *);
5738 if (current_language->la_language == language_cplus
5739 || current_language->la_language == language_fortran
5740 || current_language->la_language == language_d)
5742 /* NAME is already canonical. Drop any qualifiers as
5743 .debug_names does not contain any. */
5745 if (strchr (name, '(') != NULL)
5747 gdb::unique_xmalloc_ptr<char> without_params
5748 = cp_remove_params (name);
5750 if (without_params != NULL)
5752 name = without_params.get();
5757 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5759 const uint32_t full_hash = dwarf5_djb_hash (name);
5761 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5762 (map.bucket_table_reordered
5763 + (full_hash % map.bucket_count)), 4,
5764 map.dwarf5_byte_order);
5768 if (namei >= map.name_count)
5770 complaint (&symfile_complaints,
5771 _("Wrong .debug_names with name index %u but name_count=%u "
5773 namei, map.name_count,
5774 objfile_name (map.dwarf2_per_objfile->objfile));
5780 const uint32_t namei_full_hash
5781 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5782 (map.hash_table_reordered + namei), 4,
5783 map.dwarf5_byte_order);
5784 if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5787 if (full_hash == namei_full_hash)
5789 const char *const namei_string = map.namei_to_name (namei);
5791 #if 0 /* An expensive sanity check. */
5792 if (namei_full_hash != dwarf5_djb_hash (namei_string))
5794 complaint (&symfile_complaints,
5795 _("Wrong .debug_names hash for string at index %u "
5797 namei, objfile_name (dwarf2_per_objfile->objfile));
5802 if (cmp (namei_string, name) == 0)
5804 const ULONGEST namei_entry_offs
5805 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5806 + namei * map.offset_size),
5807 map.offset_size, map.dwarf5_byte_order);
5808 return map.entry_pool + namei_entry_offs;
5813 if (namei >= map.name_count)
5819 dw2_debug_names_iterator::find_vec_in_debug_names
5820 (const mapped_debug_names &map, uint32_t namei)
5822 if (namei >= map.name_count)
5824 complaint (&symfile_complaints,
5825 _("Wrong .debug_names with name index %u but name_count=%u "
5827 namei, map.name_count,
5828 objfile_name (map.dwarf2_per_objfile->objfile));
5832 const ULONGEST namei_entry_offs
5833 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5834 + namei * map.offset_size),
5835 map.offset_size, map.dwarf5_byte_order);
5836 return map.entry_pool + namei_entry_offs;
5839 /* See dw2_debug_names_iterator. */
5841 dwarf2_per_cu_data *
5842 dw2_debug_names_iterator::next ()
5847 struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5848 struct objfile *objfile = dwarf2_per_objfile->objfile;
5849 bfd *const abfd = objfile->obfd;
5853 unsigned int bytes_read;
5854 const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5855 m_addr += bytes_read;
5859 const auto indexval_it = m_map.abbrev_map.find (abbrev);
5860 if (indexval_it == m_map.abbrev_map.cend ())
5862 complaint (&symfile_complaints,
5863 _("Wrong .debug_names undefined abbrev code %s "
5865 pulongest (abbrev), objfile_name (objfile));
5868 const mapped_debug_names::index_val &indexval = indexval_it->second;
5869 bool have_is_static = false;
5871 dwarf2_per_cu_data *per_cu = NULL;
5872 for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5877 case DW_FORM_implicit_const:
5878 ull = attr.implicit_const;
5880 case DW_FORM_flag_present:
5884 ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5885 m_addr += bytes_read;
5888 complaint (&symfile_complaints,
5889 _("Unsupported .debug_names form %s [in module %s]"),
5890 dwarf_form_name (attr.form),
5891 objfile_name (objfile));
5894 switch (attr.dw_idx)
5896 case DW_IDX_compile_unit:
5897 /* Don't crash on bad data. */
5898 if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5900 complaint (&symfile_complaints,
5901 _(".debug_names entry has bad CU index %s"
5904 objfile_name (dwarf2_per_objfile->objfile));
5907 per_cu = dwarf2_per_objfile->get_cutu (ull);
5909 case DW_IDX_type_unit:
5910 /* Don't crash on bad data. */
5911 if (ull >= dwarf2_per_objfile->all_type_units.size ())
5913 complaint (&symfile_complaints,
5914 _(".debug_names entry has bad TU index %s"
5917 objfile_name (dwarf2_per_objfile->objfile));
5920 per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5922 case DW_IDX_GNU_internal:
5923 if (!m_map.augmentation_is_gdb)
5925 have_is_static = true;
5928 case DW_IDX_GNU_external:
5929 if (!m_map.augmentation_is_gdb)
5931 have_is_static = true;
5937 /* Skip if already read in. */
5938 if (per_cu->v.quick->compunit_symtab)
5941 /* Check static vs global. */
5944 const bool want_static = m_block_index != GLOBAL_BLOCK;
5945 if (m_want_specific_block && want_static != is_static)
5949 /* Match dw2_symtab_iter_next, symbol_kind
5950 and debug_names::psymbol_tag. */
5954 switch (indexval.dwarf_tag)
5956 case DW_TAG_variable:
5957 case DW_TAG_subprogram:
5958 /* Some types are also in VAR_DOMAIN. */
5959 case DW_TAG_typedef:
5960 case DW_TAG_structure_type:
5967 switch (indexval.dwarf_tag)
5969 case DW_TAG_typedef:
5970 case DW_TAG_structure_type:
5977 switch (indexval.dwarf_tag)
5980 case DW_TAG_variable:
5990 /* Match dw2_expand_symtabs_matching, symbol_kind and
5991 debug_names::psymbol_tag. */
5994 case VARIABLES_DOMAIN:
5995 switch (indexval.dwarf_tag)
5997 case DW_TAG_variable:
6003 case FUNCTIONS_DOMAIN:
6004 switch (indexval.dwarf_tag)
6006 case DW_TAG_subprogram:
6013 switch (indexval.dwarf_tag)
6015 case DW_TAG_typedef:
6016 case DW_TAG_structure_type:
6029 static struct compunit_symtab *
6030 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6031 const char *name, domain_enum domain)
6033 const block_enum block_index = static_cast<block_enum> (block_index_int);
6034 struct dwarf2_per_objfile *dwarf2_per_objfile
6035 = get_dwarf2_per_objfile (objfile);
6037 const auto &mapp = dwarf2_per_objfile->debug_names_table;
6040 /* index is NULL if OBJF_READNOW. */
6043 const auto &map = *mapp;
6045 dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6046 block_index, domain, name);
6048 struct compunit_symtab *stab_best = NULL;
6049 struct dwarf2_per_cu_data *per_cu;
6050 while ((per_cu = iter.next ()) != NULL)
6052 struct symbol *sym, *with_opaque = NULL;
6053 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6054 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6055 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6057 sym = block_find_symbol (block, name, domain,
6058 block_find_non_opaque_type_preferred,
6061 /* Some caution must be observed with overloaded functions and
6062 methods, since the index will not contain any overload
6063 information (but NAME might contain it). */
6066 && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6068 if (with_opaque != NULL
6069 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6072 /* Keep looking through other CUs. */
6078 /* This dumps minimal information about .debug_names. It is called
6079 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6080 uses this to verify that .debug_names has been loaded. */
6083 dw2_debug_names_dump (struct objfile *objfile)
6085 struct dwarf2_per_objfile *dwarf2_per_objfile
6086 = get_dwarf2_per_objfile (objfile);
6088 gdb_assert (dwarf2_per_objfile->using_index);
6089 printf_filtered (".debug_names:");
6090 if (dwarf2_per_objfile->debug_names_table)
6091 printf_filtered (" exists\n");
6093 printf_filtered (" faked for \"readnow\"\n");
6094 printf_filtered ("\n");
6098 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6099 const char *func_name)
6101 struct dwarf2_per_objfile *dwarf2_per_objfile
6102 = get_dwarf2_per_objfile (objfile);
6104 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6105 if (dwarf2_per_objfile->debug_names_table)
6107 const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6109 /* Note: It doesn't matter what we pass for block_index here. */
6110 dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6111 GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6113 struct dwarf2_per_cu_data *per_cu;
6114 while ((per_cu = iter.next ()) != NULL)
6115 dw2_instantiate_symtab (per_cu, false);
6120 dw2_debug_names_expand_symtabs_matching
6121 (struct objfile *objfile,
6122 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6123 const lookup_name_info &lookup_name,
6124 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6125 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6126 enum search_domain kind)
6128 struct dwarf2_per_objfile *dwarf2_per_objfile
6129 = get_dwarf2_per_objfile (objfile);
6131 /* debug_names_table is NULL if OBJF_READNOW. */
6132 if (!dwarf2_per_objfile->debug_names_table)
6135 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6137 mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6139 dw2_expand_symtabs_matching_symbol (map, lookup_name,
6141 kind, [&] (offset_type namei)
6143 /* The name was matched, now expand corresponding CUs that were
6145 dw2_debug_names_iterator iter (map, kind, namei);
6147 struct dwarf2_per_cu_data *per_cu;
6148 while ((per_cu = iter.next ()) != NULL)
6149 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6154 const struct quick_symbol_functions dwarf2_debug_names_functions =
6157 dw2_find_last_source_symtab,
6158 dw2_forget_cached_source_info,
6159 dw2_map_symtabs_matching_filename,
6160 dw2_debug_names_lookup_symbol,
6162 dw2_debug_names_dump,
6164 dw2_debug_names_expand_symtabs_for_function,
6165 dw2_expand_all_symtabs,
6166 dw2_expand_symtabs_with_fullname,
6167 dw2_map_matching_symbols,
6168 dw2_debug_names_expand_symtabs_matching,
6169 dw2_find_pc_sect_compunit_symtab,
6171 dw2_map_symbol_filenames
6174 /* See symfile.h. */
6177 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6179 struct dwarf2_per_objfile *dwarf2_per_objfile
6180 = get_dwarf2_per_objfile (objfile);
6182 /* If we're about to read full symbols, don't bother with the
6183 indices. In this case we also don't care if some other debug
6184 format is making psymtabs, because they are all about to be
6186 if ((objfile->flags & OBJF_READNOW))
6188 dwarf2_per_objfile->using_index = 1;
6189 create_all_comp_units (dwarf2_per_objfile);
6190 create_all_type_units (dwarf2_per_objfile);
6191 dwarf2_per_objfile->quick_file_names_table
6192 = create_quick_file_names_table
6193 (dwarf2_per_objfile->all_comp_units.size ());
6195 for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6196 + dwarf2_per_objfile->all_type_units.size ()); ++i)
6198 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6200 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6201 struct dwarf2_per_cu_quick_data);
6204 /* Return 1 so that gdb sees the "quick" functions. However,
6205 these functions will be no-ops because we will have expanded
6207 *index_kind = dw_index_kind::GDB_INDEX;
6211 if (dwarf2_read_debug_names (dwarf2_per_objfile))
6213 *index_kind = dw_index_kind::DEBUG_NAMES;
6217 if (dwarf2_read_index (dwarf2_per_objfile))
6219 *index_kind = dw_index_kind::GDB_INDEX;
6228 /* Build a partial symbol table. */
6231 dwarf2_build_psymtabs (struct objfile *objfile)
6233 struct dwarf2_per_objfile *dwarf2_per_objfile
6234 = get_dwarf2_per_objfile (objfile);
6236 if (objfile->global_psymbols.capacity () == 0
6237 && objfile->static_psymbols.capacity () == 0)
6238 init_psymbol_list (objfile, 1024);
6242 /* This isn't really ideal: all the data we allocate on the
6243 objfile's obstack is still uselessly kept around. However,
6244 freeing it seems unsafe. */
6245 psymtab_discarder psymtabs (objfile);
6246 dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6249 CATCH (except, RETURN_MASK_ERROR)
6251 exception_print (gdb_stderr, except);
6256 /* Return the total length of the CU described by HEADER. */
6259 get_cu_length (const struct comp_unit_head *header)
6261 return header->initial_length_size + header->length;
6264 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6267 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6269 sect_offset bottom = cu_header->sect_off;
6270 sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6272 return sect_off >= bottom && sect_off < top;
6275 /* Find the base address of the compilation unit for range lists and
6276 location lists. It will normally be specified by DW_AT_low_pc.
6277 In DWARF-3 draft 4, the base address could be overridden by
6278 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6279 compilation units with discontinuous ranges. */
6282 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6284 struct attribute *attr;
6287 cu->base_address = 0;
6289 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6292 cu->base_address = attr_value_as_address (attr);
6297 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6300 cu->base_address = attr_value_as_address (attr);
6306 /* Read in the comp unit header information from the debug_info at info_ptr.
6307 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6308 NOTE: This leaves members offset, first_die_offset to be filled in
6311 static const gdb_byte *
6312 read_comp_unit_head (struct comp_unit_head *cu_header,
6313 const gdb_byte *info_ptr,
6314 struct dwarf2_section_info *section,
6315 rcuh_kind section_kind)
6318 unsigned int bytes_read;
6319 const char *filename = get_section_file_name (section);
6320 bfd *abfd = get_section_bfd_owner (section);
6322 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6323 cu_header->initial_length_size = bytes_read;
6324 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6325 info_ptr += bytes_read;
6326 cu_header->version = read_2_bytes (abfd, info_ptr);
6328 if (cu_header->version < 5)
6329 switch (section_kind)
6331 case rcuh_kind::COMPILE:
6332 cu_header->unit_type = DW_UT_compile;
6334 case rcuh_kind::TYPE:
6335 cu_header->unit_type = DW_UT_type;
6338 internal_error (__FILE__, __LINE__,
6339 _("read_comp_unit_head: invalid section_kind"));
6343 cu_header->unit_type = static_cast<enum dwarf_unit_type>
6344 (read_1_byte (abfd, info_ptr));
6346 switch (cu_header->unit_type)
6349 if (section_kind != rcuh_kind::COMPILE)
6350 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6351 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6355 section_kind = rcuh_kind::TYPE;
6358 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6359 "(is %d, should be %d or %d) [in module %s]"),
6360 cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6363 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6366 cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6369 info_ptr += bytes_read;
6370 if (cu_header->version < 5)
6372 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6375 signed_addr = bfd_get_sign_extend_vma (abfd);
6376 if (signed_addr < 0)
6377 internal_error (__FILE__, __LINE__,
6378 _("read_comp_unit_head: dwarf from non elf file"));
6379 cu_header->signed_addr_p = signed_addr;
6381 if (section_kind == rcuh_kind::TYPE)
6383 LONGEST type_offset;
6385 cu_header->signature = read_8_bytes (abfd, info_ptr);
6388 type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6389 info_ptr += bytes_read;
6390 cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6391 if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6392 error (_("Dwarf Error: Too big type_offset in compilation unit "
6393 "header (is %s) [in module %s]"), plongest (type_offset),
6400 /* Helper function that returns the proper abbrev section for
6403 static struct dwarf2_section_info *
6404 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6406 struct dwarf2_section_info *abbrev;
6407 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6409 if (this_cu->is_dwz)
6410 abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6412 abbrev = &dwarf2_per_objfile->abbrev;
6417 /* Subroutine of read_and_check_comp_unit_head and
6418 read_and_check_type_unit_head to simplify them.
6419 Perform various error checking on the header. */
6422 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6423 struct comp_unit_head *header,
6424 struct dwarf2_section_info *section,
6425 struct dwarf2_section_info *abbrev_section)
6427 const char *filename = get_section_file_name (section);
6429 if (header->version < 2 || header->version > 5)
6430 error (_("Dwarf Error: wrong version in compilation unit header "
6431 "(is %d, should be 2, 3, 4 or 5) [in module %s]"), header->version,
6434 if (to_underlying (header->abbrev_sect_off)
6435 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6436 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6437 "(offset %s + 6) [in module %s]"),
6438 sect_offset_str (header->abbrev_sect_off),
6439 sect_offset_str (header->sect_off),
6442 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6443 avoid potential 32-bit overflow. */
6444 if (((ULONGEST) header->sect_off + get_cu_length (header))
6446 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6447 "(offset %s + 0) [in module %s]"),
6448 header->length, sect_offset_str (header->sect_off),
6452 /* Read in a CU/TU header and perform some basic error checking.
6453 The contents of the header are stored in HEADER.
6454 The result is a pointer to the start of the first DIE. */
6456 static const gdb_byte *
6457 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6458 struct comp_unit_head *header,
6459 struct dwarf2_section_info *section,
6460 struct dwarf2_section_info *abbrev_section,
6461 const gdb_byte *info_ptr,
6462 rcuh_kind section_kind)
6464 const gdb_byte *beg_of_comp_unit = info_ptr;
6466 header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6468 info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6470 header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6472 error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6478 /* Fetch the abbreviation table offset from a comp or type unit header. */
6481 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6482 struct dwarf2_section_info *section,
6483 sect_offset sect_off)
6485 bfd *abfd = get_section_bfd_owner (section);
6486 const gdb_byte *info_ptr;
6487 unsigned int initial_length_size, offset_size;
6490 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6491 info_ptr = section->buffer + to_underlying (sect_off);
6492 read_initial_length (abfd, info_ptr, &initial_length_size);
6493 offset_size = initial_length_size == 4 ? 4 : 8;
6494 info_ptr += initial_length_size;
6496 version = read_2_bytes (abfd, info_ptr);
6500 /* Skip unit type and address size. */
6504 return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6507 /* Allocate a new partial symtab for file named NAME and mark this new
6508 partial symtab as being an include of PST. */
6511 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6512 struct objfile *objfile)
6514 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6516 if (!IS_ABSOLUTE_PATH (subpst->filename))
6518 /* It shares objfile->objfile_obstack. */
6519 subpst->dirname = pst->dirname;
6522 subpst->textlow = 0;
6523 subpst->texthigh = 0;
6525 subpst->dependencies
6526 = XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
6527 subpst->dependencies[0] = pst;
6528 subpst->number_of_dependencies = 1;
6530 subpst->globals_offset = 0;
6531 subpst->n_global_syms = 0;
6532 subpst->statics_offset = 0;
6533 subpst->n_static_syms = 0;
6534 subpst->compunit_symtab = NULL;
6535 subpst->read_symtab = pst->read_symtab;
6538 /* No private part is necessary for include psymtabs. This property
6539 can be used to differentiate between such include psymtabs and
6540 the regular ones. */
6541 subpst->read_symtab_private = NULL;
6544 /* Read the Line Number Program data and extract the list of files
6545 included by the source file represented by PST. Build an include
6546 partial symtab for each of these included files. */
6549 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6550 struct die_info *die,
6551 struct partial_symtab *pst)
6554 struct attribute *attr;
6556 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6558 lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6560 return; /* No linetable, so no includes. */
6562 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
6563 dwarf_decode_lines (lh.get (), pst->dirname, cu, pst, pst->textlow, 1);
6567 hash_signatured_type (const void *item)
6569 const struct signatured_type *sig_type
6570 = (const struct signatured_type *) item;
6572 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6573 return sig_type->signature;
6577 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6579 const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6580 const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6582 return lhs->signature == rhs->signature;
6585 /* Allocate a hash table for signatured types. */
6588 allocate_signatured_type_table (struct objfile *objfile)
6590 return htab_create_alloc_ex (41,
6591 hash_signatured_type,
6594 &objfile->objfile_obstack,
6595 hashtab_obstack_allocate,
6596 dummy_obstack_deallocate);
6599 /* A helper function to add a signatured type CU to a table. */
6602 add_signatured_type_cu_to_table (void **slot, void *datum)
6604 struct signatured_type *sigt = (struct signatured_type *) *slot;
6605 std::vector<signatured_type *> *all_type_units
6606 = (std::vector<signatured_type *> *) datum;
6608 all_type_units->push_back (sigt);
6613 /* A helper for create_debug_types_hash_table. Read types from SECTION
6614 and fill them into TYPES_HTAB. It will process only type units,
6615 therefore DW_UT_type. */
6618 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6619 struct dwo_file *dwo_file,
6620 dwarf2_section_info *section, htab_t &types_htab,
6621 rcuh_kind section_kind)
6623 struct objfile *objfile = dwarf2_per_objfile->objfile;
6624 struct dwarf2_section_info *abbrev_section;
6626 const gdb_byte *info_ptr, *end_ptr;
6628 abbrev_section = (dwo_file != NULL
6629 ? &dwo_file->sections.abbrev
6630 : &dwarf2_per_objfile->abbrev);
6632 if (dwarf_read_debug)
6633 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6634 get_section_name (section),
6635 get_section_file_name (abbrev_section));
6637 dwarf2_read_section (objfile, section);
6638 info_ptr = section->buffer;
6640 if (info_ptr == NULL)
6643 /* We can't set abfd until now because the section may be empty or
6644 not present, in which case the bfd is unknown. */
6645 abfd = get_section_bfd_owner (section);
6647 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6648 because we don't need to read any dies: the signature is in the
6651 end_ptr = info_ptr + section->size;
6652 while (info_ptr < end_ptr)
6654 struct signatured_type *sig_type;
6655 struct dwo_unit *dwo_tu;
6657 const gdb_byte *ptr = info_ptr;
6658 struct comp_unit_head header;
6659 unsigned int length;
6661 sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6663 /* Initialize it due to a false compiler warning. */
6664 header.signature = -1;
6665 header.type_cu_offset_in_tu = (cu_offset) -1;
6667 /* We need to read the type's signature in order to build the hash
6668 table, but we don't need anything else just yet. */
6670 ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6671 abbrev_section, ptr, section_kind);
6673 length = get_cu_length (&header);
6675 /* Skip dummy type units. */
6676 if (ptr >= info_ptr + length
6677 || peek_abbrev_code (abfd, ptr) == 0
6678 || header.unit_type != DW_UT_type)
6684 if (types_htab == NULL)
6687 types_htab = allocate_dwo_unit_table (objfile);
6689 types_htab = allocate_signatured_type_table (objfile);
6695 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6697 dwo_tu->dwo_file = dwo_file;
6698 dwo_tu->signature = header.signature;
6699 dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6700 dwo_tu->section = section;
6701 dwo_tu->sect_off = sect_off;
6702 dwo_tu->length = length;
6706 /* N.B.: type_offset is not usable if this type uses a DWO file.
6707 The real type_offset is in the DWO file. */
6709 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6710 struct signatured_type);
6711 sig_type->signature = header.signature;
6712 sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6713 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6714 sig_type->per_cu.is_debug_types = 1;
6715 sig_type->per_cu.section = section;
6716 sig_type->per_cu.sect_off = sect_off;
6717 sig_type->per_cu.length = length;
6720 slot = htab_find_slot (types_htab,
6721 dwo_file ? (void*) dwo_tu : (void *) sig_type,
6723 gdb_assert (slot != NULL);
6726 sect_offset dup_sect_off;
6730 const struct dwo_unit *dup_tu
6731 = (const struct dwo_unit *) *slot;
6733 dup_sect_off = dup_tu->sect_off;
6737 const struct signatured_type *dup_tu
6738 = (const struct signatured_type *) *slot;
6740 dup_sect_off = dup_tu->per_cu.sect_off;
6743 complaint (&symfile_complaints,
6744 _("debug type entry at offset %s is duplicate to"
6745 " the entry at offset %s, signature %s"),
6746 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6747 hex_string (header.signature));
6749 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6751 if (dwarf_read_debug > 1)
6752 fprintf_unfiltered (gdb_stdlog, " offset %s, signature %s\n",
6753 sect_offset_str (sect_off),
6754 hex_string (header.signature));
6760 /* Create the hash table of all entries in the .debug_types
6761 (or .debug_types.dwo) section(s).
6762 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6763 otherwise it is NULL.
6765 The result is a pointer to the hash table or NULL if there are no types.
6767 Note: This function processes DWO files only, not DWP files. */
6770 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6771 struct dwo_file *dwo_file,
6772 VEC (dwarf2_section_info_def) *types,
6776 struct dwarf2_section_info *section;
6778 if (VEC_empty (dwarf2_section_info_def, types))
6782 VEC_iterate (dwarf2_section_info_def, types, ix, section);
6784 create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6785 types_htab, rcuh_kind::TYPE);
6788 /* Create the hash table of all entries in the .debug_types section,
6789 and initialize all_type_units.
6790 The result is zero if there is an error (e.g. missing .debug_types section),
6791 otherwise non-zero. */
6794 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6796 htab_t types_htab = NULL;
6798 create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6799 &dwarf2_per_objfile->info, types_htab,
6800 rcuh_kind::COMPILE);
6801 create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6802 dwarf2_per_objfile->types, types_htab);
6803 if (types_htab == NULL)
6805 dwarf2_per_objfile->signatured_types = NULL;
6809 dwarf2_per_objfile->signatured_types = types_htab;
6811 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6812 dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6814 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6815 &dwarf2_per_objfile->all_type_units);
6820 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6821 If SLOT is non-NULL, it is the entry to use in the hash table.
6822 Otherwise we find one. */
6824 static struct signatured_type *
6825 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6828 struct objfile *objfile = dwarf2_per_objfile->objfile;
6830 if (dwarf2_per_objfile->all_type_units.size ()
6831 == dwarf2_per_objfile->all_type_units.capacity ())
6832 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6834 signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6835 struct signatured_type);
6837 dwarf2_per_objfile->all_type_units.push_back (sig_type);
6838 sig_type->signature = sig;
6839 sig_type->per_cu.is_debug_types = 1;
6840 if (dwarf2_per_objfile->using_index)
6842 sig_type->per_cu.v.quick =
6843 OBSTACK_ZALLOC (&objfile->objfile_obstack,
6844 struct dwarf2_per_cu_quick_data);
6849 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6852 gdb_assert (*slot == NULL);
6854 /* The rest of sig_type must be filled in by the caller. */
6858 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6859 Fill in SIG_ENTRY with DWO_ENTRY. */
6862 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6863 struct signatured_type *sig_entry,
6864 struct dwo_unit *dwo_entry)
6866 /* Make sure we're not clobbering something we don't expect to. */
6867 gdb_assert (! sig_entry->per_cu.queued);
6868 gdb_assert (sig_entry->per_cu.cu == NULL);
6869 if (dwarf2_per_objfile->using_index)
6871 gdb_assert (sig_entry->per_cu.v.quick != NULL);
6872 gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6875 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6876 gdb_assert (sig_entry->signature == dwo_entry->signature);
6877 gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6878 gdb_assert (sig_entry->type_unit_group == NULL);
6879 gdb_assert (sig_entry->dwo_unit == NULL);
6881 sig_entry->per_cu.section = dwo_entry->section;
6882 sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6883 sig_entry->per_cu.length = dwo_entry->length;
6884 sig_entry->per_cu.reading_dwo_directly = 1;
6885 sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6886 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6887 sig_entry->dwo_unit = dwo_entry;
6890 /* Subroutine of lookup_signatured_type.
6891 If we haven't read the TU yet, create the signatured_type data structure
6892 for a TU to be read in directly from a DWO file, bypassing the stub.
6893 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6894 using .gdb_index, then when reading a CU we want to stay in the DWO file
6895 containing that CU. Otherwise we could end up reading several other DWO
6896 files (due to comdat folding) to process the transitive closure of all the
6897 mentioned TUs, and that can be slow. The current DWO file will have every
6898 type signature that it needs.
6899 We only do this for .gdb_index because in the psymtab case we already have
6900 to read all the DWOs to build the type unit groups. */
6902 static struct signatured_type *
6903 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6905 struct dwarf2_per_objfile *dwarf2_per_objfile
6906 = cu->per_cu->dwarf2_per_objfile;
6907 struct objfile *objfile = dwarf2_per_objfile->objfile;
6908 struct dwo_file *dwo_file;
6909 struct dwo_unit find_dwo_entry, *dwo_entry;
6910 struct signatured_type find_sig_entry, *sig_entry;
6913 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6915 /* If TU skeletons have been removed then we may not have read in any
6917 if (dwarf2_per_objfile->signatured_types == NULL)
6919 dwarf2_per_objfile->signatured_types
6920 = allocate_signatured_type_table (objfile);
6923 /* We only ever need to read in one copy of a signatured type.
6924 Use the global signatured_types array to do our own comdat-folding
6925 of types. If this is the first time we're reading this TU, and
6926 the TU has an entry in .gdb_index, replace the recorded data from
6927 .gdb_index with this TU. */
6929 find_sig_entry.signature = sig;
6930 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6931 &find_sig_entry, INSERT);
6932 sig_entry = (struct signatured_type *) *slot;
6934 /* We can get here with the TU already read, *or* in the process of being
6935 read. Don't reassign the global entry to point to this DWO if that's
6936 the case. Also note that if the TU is already being read, it may not
6937 have come from a DWO, the program may be a mix of Fission-compiled
6938 code and non-Fission-compiled code. */
6940 /* Have we already tried to read this TU?
6941 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6942 needn't exist in the global table yet). */
6943 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
6946 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6947 dwo_unit of the TU itself. */
6948 dwo_file = cu->dwo_unit->dwo_file;
6950 /* Ok, this is the first time we're reading this TU. */
6951 if (dwo_file->tus == NULL)
6953 find_dwo_entry.signature = sig;
6954 dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
6955 if (dwo_entry == NULL)
6958 /* If the global table doesn't have an entry for this TU, add one. */
6959 if (sig_entry == NULL)
6960 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
6962 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
6963 sig_entry->per_cu.tu_read = 1;
6967 /* Subroutine of lookup_signatured_type.
6968 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6969 then try the DWP file. If the TU stub (skeleton) has been removed then
6970 it won't be in .gdb_index. */
6972 static struct signatured_type *
6973 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6975 struct dwarf2_per_objfile *dwarf2_per_objfile
6976 = cu->per_cu->dwarf2_per_objfile;
6977 struct objfile *objfile = dwarf2_per_objfile->objfile;
6978 struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
6979 struct dwo_unit *dwo_entry;
6980 struct signatured_type find_sig_entry, *sig_entry;
6983 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6984 gdb_assert (dwp_file != NULL);
6986 /* If TU skeletons have been removed then we may not have read in any
6988 if (dwarf2_per_objfile->signatured_types == NULL)
6990 dwarf2_per_objfile->signatured_types
6991 = allocate_signatured_type_table (objfile);
6994 find_sig_entry.signature = sig;
6995 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6996 &find_sig_entry, INSERT);
6997 sig_entry = (struct signatured_type *) *slot;
6999 /* Have we already tried to read this TU?
7000 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7001 needn't exist in the global table yet). */
7002 if (sig_entry != NULL)
7005 if (dwp_file->tus == NULL)
7007 dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7008 sig, 1 /* is_debug_types */);
7009 if (dwo_entry == NULL)
7012 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7013 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7018 /* Lookup a signature based type for DW_FORM_ref_sig8.
7019 Returns NULL if signature SIG is not present in the table.
7020 It is up to the caller to complain about this. */
7022 static struct signatured_type *
7023 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7025 struct dwarf2_per_objfile *dwarf2_per_objfile
7026 = cu->per_cu->dwarf2_per_objfile;
7029 && dwarf2_per_objfile->using_index)
7031 /* We're in a DWO/DWP file, and we're using .gdb_index.
7032 These cases require special processing. */
7033 if (get_dwp_file (dwarf2_per_objfile) == NULL)
7034 return lookup_dwo_signatured_type (cu, sig);
7036 return lookup_dwp_signatured_type (cu, sig);
7040 struct signatured_type find_entry, *entry;
7042 if (dwarf2_per_objfile->signatured_types == NULL)
7044 find_entry.signature = sig;
7045 entry = ((struct signatured_type *)
7046 htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7051 /* Low level DIE reading support. */
7053 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7056 init_cu_die_reader (struct die_reader_specs *reader,
7057 struct dwarf2_cu *cu,
7058 struct dwarf2_section_info *section,
7059 struct dwo_file *dwo_file,
7060 struct abbrev_table *abbrev_table)
7062 gdb_assert (section->readin && section->buffer != NULL);
7063 reader->abfd = get_section_bfd_owner (section);
7065 reader->dwo_file = dwo_file;
7066 reader->die_section = section;
7067 reader->buffer = section->buffer;
7068 reader->buffer_end = section->buffer + section->size;
7069 reader->comp_dir = NULL;
7070 reader->abbrev_table = abbrev_table;
7073 /* Subroutine of init_cutu_and_read_dies to simplify it.
7074 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7075 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7078 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7079 from it to the DIE in the DWO. If NULL we are skipping the stub.
7080 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7081 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7082 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7083 STUB_COMP_DIR may be non-NULL.
7084 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7085 are filled in with the info of the DIE from the DWO file.
7086 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7087 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7088 kept around for at least as long as *RESULT_READER.
7090 The result is non-zero if a valid (non-dummy) DIE was found. */
7093 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7094 struct dwo_unit *dwo_unit,
7095 struct die_info *stub_comp_unit_die,
7096 const char *stub_comp_dir,
7097 struct die_reader_specs *result_reader,
7098 const gdb_byte **result_info_ptr,
7099 struct die_info **result_comp_unit_die,
7100 int *result_has_children,
7101 abbrev_table_up *result_dwo_abbrev_table)
7103 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7104 struct objfile *objfile = dwarf2_per_objfile->objfile;
7105 struct dwarf2_cu *cu = this_cu->cu;
7107 const gdb_byte *begin_info_ptr, *info_ptr;
7108 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7109 int i,num_extra_attrs;
7110 struct dwarf2_section_info *dwo_abbrev_section;
7111 struct attribute *attr;
7112 struct die_info *comp_unit_die;
7114 /* At most one of these may be provided. */
7115 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7117 /* These attributes aren't processed until later:
7118 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7119 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7120 referenced later. However, these attributes are found in the stub
7121 which we won't have later. In order to not impose this complication
7122 on the rest of the code, we read them here and copy them to the
7131 if (stub_comp_unit_die != NULL)
7133 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7135 if (! this_cu->is_debug_types)
7136 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7137 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7138 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7139 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7140 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7142 /* There should be a DW_AT_addr_base attribute here (if needed).
7143 We need the value before we can process DW_FORM_GNU_addr_index. */
7145 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7147 cu->addr_base = DW_UNSND (attr);
7149 /* There should be a DW_AT_ranges_base attribute here (if needed).
7150 We need the value before we can process DW_AT_ranges. */
7151 cu->ranges_base = 0;
7152 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7154 cu->ranges_base = DW_UNSND (attr);
7156 else if (stub_comp_dir != NULL)
7158 /* Reconstruct the comp_dir attribute to simplify the code below. */
7159 comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7160 comp_dir->name = DW_AT_comp_dir;
7161 comp_dir->form = DW_FORM_string;
7162 DW_STRING_IS_CANONICAL (comp_dir) = 0;
7163 DW_STRING (comp_dir) = stub_comp_dir;
7166 /* Set up for reading the DWO CU/TU. */
7167 cu->dwo_unit = dwo_unit;
7168 dwarf2_section_info *section = dwo_unit->section;
7169 dwarf2_read_section (objfile, section);
7170 abfd = get_section_bfd_owner (section);
7171 begin_info_ptr = info_ptr = (section->buffer
7172 + to_underlying (dwo_unit->sect_off));
7173 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7175 if (this_cu->is_debug_types)
7177 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7179 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7180 &cu->header, section,
7182 info_ptr, rcuh_kind::TYPE);
7183 /* This is not an assert because it can be caused by bad debug info. */
7184 if (sig_type->signature != cu->header.signature)
7186 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7187 " TU at offset %s [in module %s]"),
7188 hex_string (sig_type->signature),
7189 hex_string (cu->header.signature),
7190 sect_offset_str (dwo_unit->sect_off),
7191 bfd_get_filename (abfd));
7193 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7194 /* For DWOs coming from DWP files, we don't know the CU length
7195 nor the type's offset in the TU until now. */
7196 dwo_unit->length = get_cu_length (&cu->header);
7197 dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7199 /* Establish the type offset that can be used to lookup the type.
7200 For DWO files, we don't know it until now. */
7201 sig_type->type_offset_in_section
7202 = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7206 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7207 &cu->header, section,
7209 info_ptr, rcuh_kind::COMPILE);
7210 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7211 /* For DWOs coming from DWP files, we don't know the CU length
7213 dwo_unit->length = get_cu_length (&cu->header);
7216 *result_dwo_abbrev_table
7217 = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7218 cu->header.abbrev_sect_off);
7219 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7220 result_dwo_abbrev_table->get ());
7222 /* Read in the die, but leave space to copy over the attributes
7223 from the stub. This has the benefit of simplifying the rest of
7224 the code - all the work to maintain the illusion of a single
7225 DW_TAG_{compile,type}_unit DIE is done here. */
7226 num_extra_attrs = ((stmt_list != NULL)
7230 + (comp_dir != NULL));
7231 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7232 result_has_children, num_extra_attrs);
7234 /* Copy over the attributes from the stub to the DIE we just read in. */
7235 comp_unit_die = *result_comp_unit_die;
7236 i = comp_unit_die->num_attrs;
7237 if (stmt_list != NULL)
7238 comp_unit_die->attrs[i++] = *stmt_list;
7240 comp_unit_die->attrs[i++] = *low_pc;
7241 if (high_pc != NULL)
7242 comp_unit_die->attrs[i++] = *high_pc;
7244 comp_unit_die->attrs[i++] = *ranges;
7245 if (comp_dir != NULL)
7246 comp_unit_die->attrs[i++] = *comp_dir;
7247 comp_unit_die->num_attrs += num_extra_attrs;
7249 if (dwarf_die_debug)
7251 fprintf_unfiltered (gdb_stdlog,
7252 "Read die from %s@0x%x of %s:\n",
7253 get_section_name (section),
7254 (unsigned) (begin_info_ptr - section->buffer),
7255 bfd_get_filename (abfd));
7256 dump_die (comp_unit_die, dwarf_die_debug);
7259 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7260 TUs by skipping the stub and going directly to the entry in the DWO file.
7261 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7262 to get it via circuitous means. Blech. */
7263 if (comp_dir != NULL)
7264 result_reader->comp_dir = DW_STRING (comp_dir);
7266 /* Skip dummy compilation units. */
7267 if (info_ptr >= begin_info_ptr + dwo_unit->length
7268 || peek_abbrev_code (abfd, info_ptr) == 0)
7271 *result_info_ptr = info_ptr;
7275 /* Subroutine of init_cutu_and_read_dies to simplify it.
7276 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7277 Returns NULL if the specified DWO unit cannot be found. */
7279 static struct dwo_unit *
7280 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7281 struct die_info *comp_unit_die)
7283 struct dwarf2_cu *cu = this_cu->cu;
7285 struct dwo_unit *dwo_unit;
7286 const char *comp_dir, *dwo_name;
7288 gdb_assert (cu != NULL);
7290 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7291 dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7292 comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7294 if (this_cu->is_debug_types)
7296 struct signatured_type *sig_type;
7298 /* Since this_cu is the first member of struct signatured_type,
7299 we can go from a pointer to one to a pointer to the other. */
7300 sig_type = (struct signatured_type *) this_cu;
7301 signature = sig_type->signature;
7302 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7306 struct attribute *attr;
7308 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7310 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7312 dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7313 signature = DW_UNSND (attr);
7314 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7321 /* Subroutine of init_cutu_and_read_dies to simplify it.
7322 See it for a description of the parameters.
7323 Read a TU directly from a DWO file, bypassing the stub. */
7326 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7327 int use_existing_cu, int keep,
7328 die_reader_func_ftype *die_reader_func,
7331 std::unique_ptr<dwarf2_cu> new_cu;
7332 struct signatured_type *sig_type;
7333 struct die_reader_specs reader;
7334 const gdb_byte *info_ptr;
7335 struct die_info *comp_unit_die;
7337 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7339 /* Verify we can do the following downcast, and that we have the
7341 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7342 sig_type = (struct signatured_type *) this_cu;
7343 gdb_assert (sig_type->dwo_unit != NULL);
7345 if (use_existing_cu && this_cu->cu != NULL)
7347 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7348 /* There's no need to do the rereading_dwo_cu handling that
7349 init_cutu_and_read_dies does since we don't read the stub. */
7353 /* If !use_existing_cu, this_cu->cu must be NULL. */
7354 gdb_assert (this_cu->cu == NULL);
7355 new_cu.reset (new dwarf2_cu (this_cu));
7358 /* A future optimization, if needed, would be to use an existing
7359 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7360 could share abbrev tables. */
7362 /* The abbreviation table used by READER, this must live at least as long as
7364 abbrev_table_up dwo_abbrev_table;
7366 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7367 NULL /* stub_comp_unit_die */,
7368 sig_type->dwo_unit->dwo_file->comp_dir,
7370 &comp_unit_die, &has_children,
7371 &dwo_abbrev_table) == 0)
7377 /* All the "real" work is done here. */
7378 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7380 /* This duplicates the code in init_cutu_and_read_dies,
7381 but the alternative is making the latter more complex.
7382 This function is only for the special case of using DWO files directly:
7383 no point in overly complicating the general case just to handle this. */
7384 if (new_cu != NULL && keep)
7386 /* Link this CU into read_in_chain. */
7387 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7388 dwarf2_per_objfile->read_in_chain = this_cu;
7389 /* The chain owns it now. */
7394 /* Initialize a CU (or TU) and read its DIEs.
7395 If the CU defers to a DWO file, read the DWO file as well.
7397 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7398 Otherwise the table specified in the comp unit header is read in and used.
7399 This is an optimization for when we already have the abbrev table.
7401 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7402 Otherwise, a new CU is allocated with xmalloc.
7404 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7405 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7407 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7408 linker) then DIE_READER_FUNC will not get called. */
7411 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7412 struct abbrev_table *abbrev_table,
7413 int use_existing_cu, int keep,
7415 die_reader_func_ftype *die_reader_func,
7418 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7419 struct objfile *objfile = dwarf2_per_objfile->objfile;
7420 struct dwarf2_section_info *section = this_cu->section;
7421 bfd *abfd = get_section_bfd_owner (section);
7422 struct dwarf2_cu *cu;
7423 const gdb_byte *begin_info_ptr, *info_ptr;
7424 struct die_reader_specs reader;
7425 struct die_info *comp_unit_die;
7427 struct attribute *attr;
7428 struct signatured_type *sig_type = NULL;
7429 struct dwarf2_section_info *abbrev_section;
7430 /* Non-zero if CU currently points to a DWO file and we need to
7431 reread it. When this happens we need to reread the skeleton die
7432 before we can reread the DWO file (this only applies to CUs, not TUs). */
7433 int rereading_dwo_cu = 0;
7435 if (dwarf_die_debug)
7436 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7437 this_cu->is_debug_types ? "type" : "comp",
7438 sect_offset_str (this_cu->sect_off));
7440 if (use_existing_cu)
7443 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7444 file (instead of going through the stub), short-circuit all of this. */
7445 if (this_cu->reading_dwo_directly)
7447 /* Narrow down the scope of possibilities to have to understand. */
7448 gdb_assert (this_cu->is_debug_types);
7449 gdb_assert (abbrev_table == NULL);
7450 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7451 die_reader_func, data);
7455 /* This is cheap if the section is already read in. */
7456 dwarf2_read_section (objfile, section);
7458 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7460 abbrev_section = get_abbrev_section_for_cu (this_cu);
7462 std::unique_ptr<dwarf2_cu> new_cu;
7463 if (use_existing_cu && this_cu->cu != NULL)
7466 /* If this CU is from a DWO file we need to start over, we need to
7467 refetch the attributes from the skeleton CU.
7468 This could be optimized by retrieving those attributes from when we
7469 were here the first time: the previous comp_unit_die was stored in
7470 comp_unit_obstack. But there's no data yet that we need this
7472 if (cu->dwo_unit != NULL)
7473 rereading_dwo_cu = 1;
7477 /* If !use_existing_cu, this_cu->cu must be NULL. */
7478 gdb_assert (this_cu->cu == NULL);
7479 new_cu.reset (new dwarf2_cu (this_cu));
7483 /* Get the header. */
7484 if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7486 /* We already have the header, there's no need to read it in again. */
7487 info_ptr += to_underlying (cu->header.first_die_cu_offset);
7491 if (this_cu->is_debug_types)
7493 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7494 &cu->header, section,
7495 abbrev_section, info_ptr,
7498 /* Since per_cu is the first member of struct signatured_type,
7499 we can go from a pointer to one to a pointer to the other. */
7500 sig_type = (struct signatured_type *) this_cu;
7501 gdb_assert (sig_type->signature == cu->header.signature);
7502 gdb_assert (sig_type->type_offset_in_tu
7503 == cu->header.type_cu_offset_in_tu);
7504 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7506 /* LENGTH has not been set yet for type units if we're
7507 using .gdb_index. */
7508 this_cu->length = get_cu_length (&cu->header);
7510 /* Establish the type offset that can be used to lookup the type. */
7511 sig_type->type_offset_in_section =
7512 this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7514 this_cu->dwarf_version = cu->header.version;
7518 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7519 &cu->header, section,
7522 rcuh_kind::COMPILE);
7524 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7525 gdb_assert (this_cu->length == get_cu_length (&cu->header));
7526 this_cu->dwarf_version = cu->header.version;
7530 /* Skip dummy compilation units. */
7531 if (info_ptr >= begin_info_ptr + this_cu->length
7532 || peek_abbrev_code (abfd, info_ptr) == 0)
7535 /* If we don't have them yet, read the abbrevs for this compilation unit.
7536 And if we need to read them now, make sure they're freed when we're
7537 done (own the table through ABBREV_TABLE_HOLDER). */
7538 abbrev_table_up abbrev_table_holder;
7539 if (abbrev_table != NULL)
7540 gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7544 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7545 cu->header.abbrev_sect_off);
7546 abbrev_table = abbrev_table_holder.get ();
7549 /* Read the top level CU/TU die. */
7550 init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7551 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7553 if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7556 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7557 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7558 table from the DWO file and pass the ownership over to us. It will be
7559 referenced from READER, so we must make sure to free it after we're done
7562 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7563 DWO CU, that this test will fail (the attribute will not be present). */
7564 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7565 abbrev_table_up dwo_abbrev_table;
7568 struct dwo_unit *dwo_unit;
7569 struct die_info *dwo_comp_unit_die;
7573 complaint (&symfile_complaints,
7574 _("compilation unit with DW_AT_GNU_dwo_name"
7575 " has children (offset %s) [in module %s]"),
7576 sect_offset_str (this_cu->sect_off),
7577 bfd_get_filename (abfd));
7579 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7580 if (dwo_unit != NULL)
7582 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7583 comp_unit_die, NULL,
7585 &dwo_comp_unit_die, &has_children,
7586 &dwo_abbrev_table) == 0)
7591 comp_unit_die = dwo_comp_unit_die;
7595 /* Yikes, we couldn't find the rest of the DIE, we only have
7596 the stub. A complaint has already been logged. There's
7597 not much more we can do except pass on the stub DIE to
7598 die_reader_func. We don't want to throw an error on bad
7603 /* All of the above is setup for this call. Yikes. */
7604 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7606 /* Done, clean up. */
7607 if (new_cu != NULL && keep)
7609 /* Link this CU into read_in_chain. */
7610 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7611 dwarf2_per_objfile->read_in_chain = this_cu;
7612 /* The chain owns it now. */
7617 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7618 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7619 to have already done the lookup to find the DWO file).
7621 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7622 THIS_CU->is_debug_types, but nothing else.
7624 We fill in THIS_CU->length.
7626 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7627 linker) then DIE_READER_FUNC will not get called.
7629 THIS_CU->cu is always freed when done.
7630 This is done in order to not leave THIS_CU->cu in a state where we have
7631 to care whether it refers to the "main" CU or the DWO CU. */
7634 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7635 struct dwo_file *dwo_file,
7636 die_reader_func_ftype *die_reader_func,
7639 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7640 struct objfile *objfile = dwarf2_per_objfile->objfile;
7641 struct dwarf2_section_info *section = this_cu->section;
7642 bfd *abfd = get_section_bfd_owner (section);
7643 struct dwarf2_section_info *abbrev_section;
7644 const gdb_byte *begin_info_ptr, *info_ptr;
7645 struct die_reader_specs reader;
7646 struct die_info *comp_unit_die;
7649 if (dwarf_die_debug)
7650 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7651 this_cu->is_debug_types ? "type" : "comp",
7652 sect_offset_str (this_cu->sect_off));
7654 gdb_assert (this_cu->cu == NULL);
7656 abbrev_section = (dwo_file != NULL
7657 ? &dwo_file->sections.abbrev
7658 : get_abbrev_section_for_cu (this_cu));
7660 /* This is cheap if the section is already read in. */
7661 dwarf2_read_section (objfile, section);
7663 struct dwarf2_cu cu (this_cu);
7665 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7666 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7667 &cu.header, section,
7668 abbrev_section, info_ptr,
7669 (this_cu->is_debug_types
7671 : rcuh_kind::COMPILE));
7673 this_cu->length = get_cu_length (&cu.header);
7675 /* Skip dummy compilation units. */
7676 if (info_ptr >= begin_info_ptr + this_cu->length
7677 || peek_abbrev_code (abfd, info_ptr) == 0)
7680 abbrev_table_up abbrev_table
7681 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7682 cu.header.abbrev_sect_off);
7684 init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7685 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7687 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7690 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7691 does not lookup the specified DWO file.
7692 This cannot be used to read DWO files.
7694 THIS_CU->cu is always freed when done.
7695 This is done in order to not leave THIS_CU->cu in a state where we have
7696 to care whether it refers to the "main" CU or the DWO CU.
7697 We can revisit this if the data shows there's a performance issue. */
7700 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7701 die_reader_func_ftype *die_reader_func,
7704 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7707 /* Type Unit Groups.
7709 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7710 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7711 so that all types coming from the same compilation (.o file) are grouped
7712 together. A future step could be to put the types in the same symtab as
7713 the CU the types ultimately came from. */
7716 hash_type_unit_group (const void *item)
7718 const struct type_unit_group *tu_group
7719 = (const struct type_unit_group *) item;
7721 return hash_stmt_list_entry (&tu_group->hash);
7725 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7727 const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7728 const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7730 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7733 /* Allocate a hash table for type unit groups. */
7736 allocate_type_unit_groups_table (struct objfile *objfile)
7738 return htab_create_alloc_ex (3,
7739 hash_type_unit_group,
7742 &objfile->objfile_obstack,
7743 hashtab_obstack_allocate,
7744 dummy_obstack_deallocate);
7747 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7748 partial symtabs. We combine several TUs per psymtab to not let the size
7749 of any one psymtab grow too big. */
7750 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7751 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7753 /* Helper routine for get_type_unit_group.
7754 Create the type_unit_group object used to hold one or more TUs. */
7756 static struct type_unit_group *
7757 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7759 struct dwarf2_per_objfile *dwarf2_per_objfile
7760 = cu->per_cu->dwarf2_per_objfile;
7761 struct objfile *objfile = dwarf2_per_objfile->objfile;
7762 struct dwarf2_per_cu_data *per_cu;
7763 struct type_unit_group *tu_group;
7765 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7766 struct type_unit_group);
7767 per_cu = &tu_group->per_cu;
7768 per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7770 if (dwarf2_per_objfile->using_index)
7772 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7773 struct dwarf2_per_cu_quick_data);
7777 unsigned int line_offset = to_underlying (line_offset_struct);
7778 struct partial_symtab *pst;
7781 /* Give the symtab a useful name for debug purposes. */
7782 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7783 name = xstrprintf ("<type_units_%d>",
7784 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7786 name = xstrprintf ("<type_units_at_0x%x>", line_offset);
7788 pst = create_partial_symtab (per_cu, name);
7794 tu_group->hash.dwo_unit = cu->dwo_unit;
7795 tu_group->hash.line_sect_off = line_offset_struct;
7800 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7801 STMT_LIST is a DW_AT_stmt_list attribute. */
7803 static struct type_unit_group *
7804 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7806 struct dwarf2_per_objfile *dwarf2_per_objfile
7807 = cu->per_cu->dwarf2_per_objfile;
7808 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7809 struct type_unit_group *tu_group;
7811 unsigned int line_offset;
7812 struct type_unit_group type_unit_group_for_lookup;
7814 if (dwarf2_per_objfile->type_unit_groups == NULL)
7816 dwarf2_per_objfile->type_unit_groups =
7817 allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7820 /* Do we need to create a new group, or can we use an existing one? */
7824 line_offset = DW_UNSND (stmt_list);
7825 ++tu_stats->nr_symtab_sharers;
7829 /* Ugh, no stmt_list. Rare, but we have to handle it.
7830 We can do various things here like create one group per TU or
7831 spread them over multiple groups to split up the expansion work.
7832 To avoid worst case scenarios (too many groups or too large groups)
7833 we, umm, group them in bunches. */
7834 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7835 | (tu_stats->nr_stmt_less_type_units
7836 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7837 ++tu_stats->nr_stmt_less_type_units;
7840 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7841 type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7842 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7843 &type_unit_group_for_lookup, INSERT);
7846 tu_group = (struct type_unit_group *) *slot;
7847 gdb_assert (tu_group != NULL);
7851 sect_offset line_offset_struct = (sect_offset) line_offset;
7852 tu_group = create_type_unit_group (cu, line_offset_struct);
7854 ++tu_stats->nr_symtabs;
7860 /* Partial symbol tables. */
7862 /* Create a psymtab named NAME and assign it to PER_CU.
7864 The caller must fill in the following details:
7865 dirname, textlow, texthigh. */
7867 static struct partial_symtab *
7868 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7870 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7871 struct partial_symtab *pst;
7873 pst = start_psymtab_common (objfile, name, 0,
7874 objfile->global_psymbols,
7875 objfile->static_psymbols);
7877 pst->psymtabs_addrmap_supported = 1;
7879 /* This is the glue that links PST into GDB's symbol API. */
7880 pst->read_symtab_private = per_cu;
7881 pst->read_symtab = dwarf2_read_symtab;
7882 per_cu->v.psymtab = pst;
7887 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7890 struct process_psymtab_comp_unit_data
7892 /* True if we are reading a DW_TAG_partial_unit. */
7894 int want_partial_unit;
7896 /* The "pretend" language that is used if the CU doesn't declare a
7899 enum language pretend_language;
7902 /* die_reader_func for process_psymtab_comp_unit. */
7905 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7906 const gdb_byte *info_ptr,
7907 struct die_info *comp_unit_die,
7911 struct dwarf2_cu *cu = reader->cu;
7912 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7913 struct gdbarch *gdbarch = get_objfile_arch (objfile);
7914 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7916 CORE_ADDR best_lowpc = 0, best_highpc = 0;
7917 struct partial_symtab *pst;
7918 enum pc_bounds_kind cu_bounds_kind;
7919 const char *filename;
7920 struct process_psymtab_comp_unit_data *info
7921 = (struct process_psymtab_comp_unit_data *) data;
7923 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
7926 gdb_assert (! per_cu->is_debug_types);
7928 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
7930 cu->list_in_scope = &file_symbols;
7932 /* Allocate a new partial symbol table structure. */
7933 filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
7934 if (filename == NULL)
7937 pst = create_partial_symtab (per_cu, filename);
7939 /* This must be done before calling dwarf2_build_include_psymtabs. */
7940 pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7942 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7944 dwarf2_find_base_address (comp_unit_die, cu);
7946 /* Possibly set the default values of LOWPC and HIGHPC from
7948 cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
7949 &best_highpc, cu, pst);
7950 if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
7951 /* Store the contiguous range if it is not empty; it can be empty for
7952 CUs with no code. */
7953 addrmap_set_empty (objfile->psymtabs_addrmap,
7954 gdbarch_adjust_dwarf2_addr (gdbarch,
7955 best_lowpc + baseaddr),
7956 gdbarch_adjust_dwarf2_addr (gdbarch,
7957 best_highpc + baseaddr) - 1,
7960 /* Check if comp unit has_children.
7961 If so, read the rest of the partial symbols from this comp unit.
7962 If not, there's no more debug_info for this comp unit. */
7965 struct partial_die_info *first_die;
7966 CORE_ADDR lowpc, highpc;
7968 lowpc = ((CORE_ADDR) -1);
7969 highpc = ((CORE_ADDR) 0);
7971 first_die = load_partial_dies (reader, info_ptr, 1);
7973 scan_partial_symbols (first_die, &lowpc, &highpc,
7974 cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
7976 /* If we didn't find a lowpc, set it to highpc to avoid
7977 complaints from `maint check'. */
7978 if (lowpc == ((CORE_ADDR) -1))
7981 /* If the compilation unit didn't have an explicit address range,
7982 then use the information extracted from its child dies. */
7983 if (cu_bounds_kind <= PC_BOUNDS_INVALID)
7986 best_highpc = highpc;
7989 pst->textlow = gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr);
7990 pst->texthigh = gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr);
7992 end_psymtab_common (objfile, pst);
7994 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
7997 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
7998 struct dwarf2_per_cu_data *iter;
8000 /* Fill in 'dependencies' here; we fill in 'users' in a
8002 pst->number_of_dependencies = len;
8004 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8006 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8009 pst->dependencies[i] = iter->v.psymtab;
8011 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8014 /* Get the list of files included in the current compilation unit,
8015 and build a psymtab for each of them. */
8016 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8018 if (dwarf_read_debug)
8020 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8022 fprintf_unfiltered (gdb_stdlog,
8023 "Psymtab for %s unit @%s: %s - %s"
8024 ", %d global, %d static syms\n",
8025 per_cu->is_debug_types ? "type" : "comp",
8026 sect_offset_str (per_cu->sect_off),
8027 paddress (gdbarch, pst->textlow),
8028 paddress (gdbarch, pst->texthigh),
8029 pst->n_global_syms, pst->n_static_syms);
8033 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8034 Process compilation unit THIS_CU for a psymtab. */
8037 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8038 int want_partial_unit,
8039 enum language pretend_language)
8041 /* If this compilation unit was already read in, free the
8042 cached copy in order to read it in again. This is
8043 necessary because we skipped some symbols when we first
8044 read in the compilation unit (see load_partial_dies).
8045 This problem could be avoided, but the benefit is unclear. */
8046 if (this_cu->cu != NULL)
8047 free_one_cached_comp_unit (this_cu);
8049 if (this_cu->is_debug_types)
8050 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8051 build_type_psymtabs_reader, NULL);
8054 process_psymtab_comp_unit_data info;
8055 info.want_partial_unit = want_partial_unit;
8056 info.pretend_language = pretend_language;
8057 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8058 process_psymtab_comp_unit_reader, &info);
8061 /* Age out any secondary CUs. */
8062 age_cached_comp_units (this_cu->dwarf2_per_objfile);
8065 /* Reader function for build_type_psymtabs. */
8068 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8069 const gdb_byte *info_ptr,
8070 struct die_info *type_unit_die,
8074 struct dwarf2_per_objfile *dwarf2_per_objfile
8075 = reader->cu->per_cu->dwarf2_per_objfile;
8076 struct objfile *objfile = dwarf2_per_objfile->objfile;
8077 struct dwarf2_cu *cu = reader->cu;
8078 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8079 struct signatured_type *sig_type;
8080 struct type_unit_group *tu_group;
8081 struct attribute *attr;
8082 struct partial_die_info *first_die;
8083 CORE_ADDR lowpc, highpc;
8084 struct partial_symtab *pst;
8086 gdb_assert (data == NULL);
8087 gdb_assert (per_cu->is_debug_types);
8088 sig_type = (struct signatured_type *) per_cu;
8093 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8094 tu_group = get_type_unit_group (cu, attr);
8096 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8098 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8099 cu->list_in_scope = &file_symbols;
8100 pst = create_partial_symtab (per_cu, "");
8103 first_die = load_partial_dies (reader, info_ptr, 1);
8105 lowpc = (CORE_ADDR) -1;
8106 highpc = (CORE_ADDR) 0;
8107 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8109 end_psymtab_common (objfile, pst);
8112 /* Struct used to sort TUs by their abbreviation table offset. */
8114 struct tu_abbrev_offset
8116 tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8117 : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8120 signatured_type *sig_type;
8121 sect_offset abbrev_offset;
8124 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8127 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8128 const struct tu_abbrev_offset &b)
8130 return a.abbrev_offset < b.abbrev_offset;
8133 /* Efficiently read all the type units.
8134 This does the bulk of the work for build_type_psymtabs.
8136 The efficiency is because we sort TUs by the abbrev table they use and
8137 only read each abbrev table once. In one program there are 200K TUs
8138 sharing 8K abbrev tables.
8140 The main purpose of this function is to support building the
8141 dwarf2_per_objfile->type_unit_groups table.
8142 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8143 can collapse the search space by grouping them by stmt_list.
8144 The savings can be significant, in the same program from above the 200K TUs
8145 share 8K stmt_list tables.
8147 FUNC is expected to call get_type_unit_group, which will create the
8148 struct type_unit_group if necessary and add it to
8149 dwarf2_per_objfile->type_unit_groups. */
8152 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8154 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8155 abbrev_table_up abbrev_table;
8156 sect_offset abbrev_offset;
8158 /* It's up to the caller to not call us multiple times. */
8159 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8161 if (dwarf2_per_objfile->all_type_units.empty ())
8164 /* TUs typically share abbrev tables, and there can be way more TUs than
8165 abbrev tables. Sort by abbrev table to reduce the number of times we
8166 read each abbrev table in.
8167 Alternatives are to punt or to maintain a cache of abbrev tables.
8168 This is simpler and efficient enough for now.
8170 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8171 symtab to use). Typically TUs with the same abbrev offset have the same
8172 stmt_list value too so in practice this should work well.
8174 The basic algorithm here is:
8176 sort TUs by abbrev table
8177 for each TU with same abbrev table:
8178 read abbrev table if first user
8179 read TU top level DIE
8180 [IWBN if DWO skeletons had DW_AT_stmt_list]
8183 if (dwarf_read_debug)
8184 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8186 /* Sort in a separate table to maintain the order of all_type_units
8187 for .gdb_index: TU indices directly index all_type_units. */
8188 std::vector<tu_abbrev_offset> sorted_by_abbrev;
8189 sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8191 for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8192 sorted_by_abbrev.emplace_back
8193 (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8194 sig_type->per_cu.section,
8195 sig_type->per_cu.sect_off));
8197 std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8198 sort_tu_by_abbrev_offset);
8200 abbrev_offset = (sect_offset) ~(unsigned) 0;
8202 for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8204 /* Switch to the next abbrev table if necessary. */
8205 if (abbrev_table == NULL
8206 || tu.abbrev_offset != abbrev_offset)
8208 abbrev_offset = tu.abbrev_offset;
8210 abbrev_table_read_table (dwarf2_per_objfile,
8211 &dwarf2_per_objfile->abbrev,
8213 ++tu_stats->nr_uniq_abbrev_tables;
8216 init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8217 0, 0, false, build_type_psymtabs_reader, NULL);
8221 /* Print collected type unit statistics. */
8224 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8226 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8228 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8229 fprintf_unfiltered (gdb_stdlog, " %zu TUs\n",
8230 dwarf2_per_objfile->all_type_units.size ());
8231 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
8232 tu_stats->nr_uniq_abbrev_tables);
8233 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
8234 tu_stats->nr_symtabs);
8235 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
8236 tu_stats->nr_symtab_sharers);
8237 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
8238 tu_stats->nr_stmt_less_type_units);
8239 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
8240 tu_stats->nr_all_type_units_reallocs);
8243 /* Traversal function for build_type_psymtabs. */
8246 build_type_psymtab_dependencies (void **slot, void *info)
8248 struct dwarf2_per_objfile *dwarf2_per_objfile
8249 = (struct dwarf2_per_objfile *) info;
8250 struct objfile *objfile = dwarf2_per_objfile->objfile;
8251 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8252 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8253 struct partial_symtab *pst = per_cu->v.psymtab;
8254 int len = VEC_length (sig_type_ptr, tu_group->tus);
8255 struct signatured_type *iter;
8258 gdb_assert (len > 0);
8259 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8261 pst->number_of_dependencies = len;
8263 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8265 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8268 gdb_assert (iter->per_cu.is_debug_types);
8269 pst->dependencies[i] = iter->per_cu.v.psymtab;
8270 iter->type_unit_group = tu_group;
8273 VEC_free (sig_type_ptr, tu_group->tus);
8278 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8279 Build partial symbol tables for the .debug_types comp-units. */
8282 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8284 if (! create_all_type_units (dwarf2_per_objfile))
8287 build_type_psymtabs_1 (dwarf2_per_objfile);
8290 /* Traversal function for process_skeletonless_type_unit.
8291 Read a TU in a DWO file and build partial symbols for it. */
8294 process_skeletonless_type_unit (void **slot, void *info)
8296 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8297 struct dwarf2_per_objfile *dwarf2_per_objfile
8298 = (struct dwarf2_per_objfile *) info;
8299 struct signatured_type find_entry, *entry;
8301 /* If this TU doesn't exist in the global table, add it and read it in. */
8303 if (dwarf2_per_objfile->signatured_types == NULL)
8305 dwarf2_per_objfile->signatured_types
8306 = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8309 find_entry.signature = dwo_unit->signature;
8310 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8312 /* If we've already seen this type there's nothing to do. What's happening
8313 is we're doing our own version of comdat-folding here. */
8317 /* This does the job that create_all_type_units would have done for
8319 entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8320 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8323 /* This does the job that build_type_psymtabs_1 would have done. */
8324 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8325 build_type_psymtabs_reader, NULL);
8330 /* Traversal function for process_skeletonless_type_units. */
8333 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8335 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8337 if (dwo_file->tus != NULL)
8339 htab_traverse_noresize (dwo_file->tus,
8340 process_skeletonless_type_unit, info);
8346 /* Scan all TUs of DWO files, verifying we've processed them.
8347 This is needed in case a TU was emitted without its skeleton.
8348 Note: This can't be done until we know what all the DWO files are. */
8351 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8353 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8354 if (get_dwp_file (dwarf2_per_objfile) == NULL
8355 && dwarf2_per_objfile->dwo_files != NULL)
8357 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8358 process_dwo_file_for_skeletonless_type_units,
8359 dwarf2_per_objfile);
8363 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8366 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8368 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8370 struct partial_symtab *pst = per_cu->v.psymtab;
8375 for (int j = 0; j < pst->number_of_dependencies; ++j)
8377 /* Set the 'user' field only if it is not already set. */
8378 if (pst->dependencies[j]->user == NULL)
8379 pst->dependencies[j]->user = pst;
8384 /* Build the partial symbol table by doing a quick pass through the
8385 .debug_info and .debug_abbrev sections. */
8388 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8390 struct objfile *objfile = dwarf2_per_objfile->objfile;
8392 if (dwarf_read_debug)
8394 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8395 objfile_name (objfile));
8398 dwarf2_per_objfile->reading_partial_symbols = 1;
8400 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8402 /* Any cached compilation units will be linked by the per-objfile
8403 read_in_chain. Make sure to free them when we're done. */
8404 free_cached_comp_units freer (dwarf2_per_objfile);
8406 build_type_psymtabs (dwarf2_per_objfile);
8408 create_all_comp_units (dwarf2_per_objfile);
8410 /* Create a temporary address map on a temporary obstack. We later
8411 copy this to the final obstack. */
8412 auto_obstack temp_obstack;
8414 scoped_restore save_psymtabs_addrmap
8415 = make_scoped_restore (&objfile->psymtabs_addrmap,
8416 addrmap_create_mutable (&temp_obstack));
8418 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8419 process_psymtab_comp_unit (per_cu, 0, language_minimal);
8421 /* This has to wait until we read the CUs, we need the list of DWOs. */
8422 process_skeletonless_type_units (dwarf2_per_objfile);
8424 /* Now that all TUs have been processed we can fill in the dependencies. */
8425 if (dwarf2_per_objfile->type_unit_groups != NULL)
8427 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8428 build_type_psymtab_dependencies, dwarf2_per_objfile);
8431 if (dwarf_read_debug)
8432 print_tu_stats (dwarf2_per_objfile);
8434 set_partial_user (dwarf2_per_objfile);
8436 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
8437 &objfile->objfile_obstack);
8438 /* At this point we want to keep the address map. */
8439 save_psymtabs_addrmap.release ();
8441 if (dwarf_read_debug)
8442 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8443 objfile_name (objfile));
8446 /* die_reader_func for load_partial_comp_unit. */
8449 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8450 const gdb_byte *info_ptr,
8451 struct die_info *comp_unit_die,
8455 struct dwarf2_cu *cu = reader->cu;
8457 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8459 /* Check if comp unit has_children.
8460 If so, read the rest of the partial symbols from this comp unit.
8461 If not, there's no more debug_info for this comp unit. */
8463 load_partial_dies (reader, info_ptr, 0);
8466 /* Load the partial DIEs for a secondary CU into memory.
8467 This is also used when rereading a primary CU with load_all_dies. */
8470 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8472 init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8473 load_partial_comp_unit_reader, NULL);
8477 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8478 struct dwarf2_section_info *section,
8479 struct dwarf2_section_info *abbrev_section,
8480 unsigned int is_dwz)
8482 const gdb_byte *info_ptr;
8483 struct objfile *objfile = dwarf2_per_objfile->objfile;
8485 if (dwarf_read_debug)
8486 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8487 get_section_name (section),
8488 get_section_file_name (section));
8490 dwarf2_read_section (objfile, section);
8492 info_ptr = section->buffer;
8494 while (info_ptr < section->buffer + section->size)
8496 struct dwarf2_per_cu_data *this_cu;
8498 sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8500 comp_unit_head cu_header;
8501 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8502 abbrev_section, info_ptr,
8503 rcuh_kind::COMPILE);
8505 /* Save the compilation unit for later lookup. */
8506 if (cu_header.unit_type != DW_UT_type)
8508 this_cu = XOBNEW (&objfile->objfile_obstack,
8509 struct dwarf2_per_cu_data);
8510 memset (this_cu, 0, sizeof (*this_cu));
8514 auto sig_type = XOBNEW (&objfile->objfile_obstack,
8515 struct signatured_type);
8516 memset (sig_type, 0, sizeof (*sig_type));
8517 sig_type->signature = cu_header.signature;
8518 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8519 this_cu = &sig_type->per_cu;
8521 this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8522 this_cu->sect_off = sect_off;
8523 this_cu->length = cu_header.length + cu_header.initial_length_size;
8524 this_cu->is_dwz = is_dwz;
8525 this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8526 this_cu->section = section;
8528 dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8530 info_ptr = info_ptr + this_cu->length;
8534 /* Create a list of all compilation units in OBJFILE.
8535 This is only done for -readnow and building partial symtabs. */
8538 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8540 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8541 read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8542 &dwarf2_per_objfile->abbrev, 0);
8544 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8546 read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8550 /* Process all loaded DIEs for compilation unit CU, starting at
8551 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8552 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8553 DW_AT_ranges). See the comments of add_partial_subprogram on how
8554 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8557 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8558 CORE_ADDR *highpc, int set_addrmap,
8559 struct dwarf2_cu *cu)
8561 struct partial_die_info *pdi;
8563 /* Now, march along the PDI's, descending into ones which have
8564 interesting children but skipping the children of the other ones,
8565 until we reach the end of the compilation unit. */
8573 /* Anonymous namespaces or modules have no name but have interesting
8574 children, so we need to look at them. Ditto for anonymous
8577 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8578 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8579 || pdi->tag == DW_TAG_imported_unit
8580 || pdi->tag == DW_TAG_inlined_subroutine)
8584 case DW_TAG_subprogram:
8585 case DW_TAG_inlined_subroutine:
8586 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8588 case DW_TAG_constant:
8589 case DW_TAG_variable:
8590 case DW_TAG_typedef:
8591 case DW_TAG_union_type:
8592 if (!pdi->is_declaration)
8594 add_partial_symbol (pdi, cu);
8597 case DW_TAG_class_type:
8598 case DW_TAG_interface_type:
8599 case DW_TAG_structure_type:
8600 if (!pdi->is_declaration)
8602 add_partial_symbol (pdi, cu);
8604 if ((cu->language == language_rust
8605 || cu->language == language_cplus) && pdi->has_children)
8606 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8609 case DW_TAG_enumeration_type:
8610 if (!pdi->is_declaration)
8611 add_partial_enumeration (pdi, cu);
8613 case DW_TAG_base_type:
8614 case DW_TAG_subrange_type:
8615 /* File scope base type definitions are added to the partial
8617 add_partial_symbol (pdi, cu);
8619 case DW_TAG_namespace:
8620 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8623 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8625 case DW_TAG_imported_unit:
8627 struct dwarf2_per_cu_data *per_cu;
8629 /* For now we don't handle imported units in type units. */
8630 if (cu->per_cu->is_debug_types)
8632 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8633 " supported in type units [in module %s]"),
8634 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8637 per_cu = dwarf2_find_containing_comp_unit
8638 (pdi->d.sect_off, pdi->is_dwz,
8639 cu->per_cu->dwarf2_per_objfile);
8641 /* Go read the partial unit, if needed. */
8642 if (per_cu->v.psymtab == NULL)
8643 process_psymtab_comp_unit (per_cu, 1, cu->language);
8645 VEC_safe_push (dwarf2_per_cu_ptr,
8646 cu->per_cu->imported_symtabs, per_cu);
8649 case DW_TAG_imported_declaration:
8650 add_partial_symbol (pdi, cu);
8657 /* If the die has a sibling, skip to the sibling. */
8659 pdi = pdi->die_sibling;
8663 /* Functions used to compute the fully scoped name of a partial DIE.
8665 Normally, this is simple. For C++, the parent DIE's fully scoped
8666 name is concatenated with "::" and the partial DIE's name.
8667 Enumerators are an exception; they use the scope of their parent
8668 enumeration type, i.e. the name of the enumeration type is not
8669 prepended to the enumerator.
8671 There are two complexities. One is DW_AT_specification; in this
8672 case "parent" means the parent of the target of the specification,
8673 instead of the direct parent of the DIE. The other is compilers
8674 which do not emit DW_TAG_namespace; in this case we try to guess
8675 the fully qualified name of structure types from their members'
8676 linkage names. This must be done using the DIE's children rather
8677 than the children of any DW_AT_specification target. We only need
8678 to do this for structures at the top level, i.e. if the target of
8679 any DW_AT_specification (if any; otherwise the DIE itself) does not
8682 /* Compute the scope prefix associated with PDI's parent, in
8683 compilation unit CU. The result will be allocated on CU's
8684 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8685 field. NULL is returned if no prefix is necessary. */
8687 partial_die_parent_scope (struct partial_die_info *pdi,
8688 struct dwarf2_cu *cu)
8690 const char *grandparent_scope;
8691 struct partial_die_info *parent, *real_pdi;
8693 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8694 then this means the parent of the specification DIE. */
8697 while (real_pdi->has_specification)
8698 real_pdi = find_partial_die (real_pdi->spec_offset,
8699 real_pdi->spec_is_dwz, cu);
8701 parent = real_pdi->die_parent;
8705 if (parent->scope_set)
8706 return parent->scope;
8710 grandparent_scope = partial_die_parent_scope (parent, cu);
8712 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8713 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8714 Work around this problem here. */
8715 if (cu->language == language_cplus
8716 && parent->tag == DW_TAG_namespace
8717 && strcmp (parent->name, "::") == 0
8718 && grandparent_scope == NULL)
8720 parent->scope = NULL;
8721 parent->scope_set = 1;
8725 if (pdi->tag == DW_TAG_enumerator)
8726 /* Enumerators should not get the name of the enumeration as a prefix. */
8727 parent->scope = grandparent_scope;
8728 else if (parent->tag == DW_TAG_namespace
8729 || parent->tag == DW_TAG_module
8730 || parent->tag == DW_TAG_structure_type
8731 || parent->tag == DW_TAG_class_type
8732 || parent->tag == DW_TAG_interface_type
8733 || parent->tag == DW_TAG_union_type
8734 || parent->tag == DW_TAG_enumeration_type)
8736 if (grandparent_scope == NULL)
8737 parent->scope = parent->name;
8739 parent->scope = typename_concat (&cu->comp_unit_obstack,
8741 parent->name, 0, cu);
8745 /* FIXME drow/2004-04-01: What should we be doing with
8746 function-local names? For partial symbols, we should probably be
8748 complaint (&symfile_complaints,
8749 _("unhandled containing DIE tag %d for DIE at %s"),
8750 parent->tag, sect_offset_str (pdi->sect_off));
8751 parent->scope = grandparent_scope;
8754 parent->scope_set = 1;
8755 return parent->scope;
8758 /* Return the fully scoped name associated with PDI, from compilation unit
8759 CU. The result will be allocated with malloc. */
8762 partial_die_full_name (struct partial_die_info *pdi,
8763 struct dwarf2_cu *cu)
8765 const char *parent_scope;
8767 /* If this is a template instantiation, we can not work out the
8768 template arguments from partial DIEs. So, unfortunately, we have
8769 to go through the full DIEs. At least any work we do building
8770 types here will be reused if full symbols are loaded later. */
8771 if (pdi->has_template_arguments)
8775 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8777 struct die_info *die;
8778 struct attribute attr;
8779 struct dwarf2_cu *ref_cu = cu;
8781 /* DW_FORM_ref_addr is using section offset. */
8782 attr.name = (enum dwarf_attribute) 0;
8783 attr.form = DW_FORM_ref_addr;
8784 attr.u.unsnd = to_underlying (pdi->sect_off);
8785 die = follow_die_ref (NULL, &attr, &ref_cu);
8787 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8791 parent_scope = partial_die_parent_scope (pdi, cu);
8792 if (parent_scope == NULL)
8795 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8799 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8801 struct dwarf2_per_objfile *dwarf2_per_objfile
8802 = cu->per_cu->dwarf2_per_objfile;
8803 struct objfile *objfile = dwarf2_per_objfile->objfile;
8804 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8806 const char *actual_name = NULL;
8808 char *built_actual_name;
8810 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8812 built_actual_name = partial_die_full_name (pdi, cu);
8813 if (built_actual_name != NULL)
8814 actual_name = built_actual_name;
8816 if (actual_name == NULL)
8817 actual_name = pdi->name;
8821 case DW_TAG_inlined_subroutine:
8822 case DW_TAG_subprogram:
8823 addr = gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr);
8824 if (pdi->is_external || cu->language == language_ada)
8826 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8827 of the global scope. But in Ada, we want to be able to access
8828 nested procedures globally. So all Ada subprograms are stored
8829 in the global scope. */
8830 add_psymbol_to_list (actual_name, strlen (actual_name),
8831 built_actual_name != NULL,
8832 VAR_DOMAIN, LOC_BLOCK,
8833 &objfile->global_psymbols,
8834 addr, cu->language, objfile);
8838 add_psymbol_to_list (actual_name, strlen (actual_name),
8839 built_actual_name != NULL,
8840 VAR_DOMAIN, LOC_BLOCK,
8841 &objfile->static_psymbols,
8842 addr, cu->language, objfile);
8845 if (pdi->main_subprogram && actual_name != NULL)
8846 set_objfile_main_name (objfile, actual_name, cu->language);
8848 case DW_TAG_constant:
8850 std::vector<partial_symbol *> *list;
8852 if (pdi->is_external)
8853 list = &objfile->global_psymbols;
8855 list = &objfile->static_psymbols;
8856 add_psymbol_to_list (actual_name, strlen (actual_name),
8857 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8858 list, 0, cu->language, objfile);
8861 case DW_TAG_variable:
8863 addr = decode_locdesc (pdi->d.locdesc, cu);
8867 && !dwarf2_per_objfile->has_section_at_zero)
8869 /* A global or static variable may also have been stripped
8870 out by the linker if unused, in which case its address
8871 will be nullified; do not add such variables into partial
8872 symbol table then. */
8874 else if (pdi->is_external)
8877 Don't enter into the minimal symbol tables as there is
8878 a minimal symbol table entry from the ELF symbols already.
8879 Enter into partial symbol table if it has a location
8880 descriptor or a type.
8881 If the location descriptor is missing, new_symbol will create
8882 a LOC_UNRESOLVED symbol, the address of the variable will then
8883 be determined from the minimal symbol table whenever the variable
8885 The address for the partial symbol table entry is not
8886 used by GDB, but it comes in handy for debugging partial symbol
8889 if (pdi->d.locdesc || pdi->has_type)
8890 add_psymbol_to_list (actual_name, strlen (actual_name),
8891 built_actual_name != NULL,
8892 VAR_DOMAIN, LOC_STATIC,
8893 &objfile->global_psymbols,
8895 cu->language, objfile);
8899 int has_loc = pdi->d.locdesc != NULL;
8901 /* Static Variable. Skip symbols whose value we cannot know (those
8902 without location descriptors or constant values). */
8903 if (!has_loc && !pdi->has_const_value)
8905 xfree (built_actual_name);
8909 add_psymbol_to_list (actual_name, strlen (actual_name),
8910 built_actual_name != NULL,
8911 VAR_DOMAIN, LOC_STATIC,
8912 &objfile->static_psymbols,
8913 has_loc ? addr + baseaddr : (CORE_ADDR) 0,
8914 cu->language, objfile);
8917 case DW_TAG_typedef:
8918 case DW_TAG_base_type:
8919 case DW_TAG_subrange_type:
8920 add_psymbol_to_list (actual_name, strlen (actual_name),
8921 built_actual_name != NULL,
8922 VAR_DOMAIN, LOC_TYPEDEF,
8923 &objfile->static_psymbols,
8924 0, cu->language, objfile);
8926 case DW_TAG_imported_declaration:
8927 case DW_TAG_namespace:
8928 add_psymbol_to_list (actual_name, strlen (actual_name),
8929 built_actual_name != NULL,
8930 VAR_DOMAIN, LOC_TYPEDEF,
8931 &objfile->global_psymbols,
8932 0, cu->language, objfile);
8935 add_psymbol_to_list (actual_name, strlen (actual_name),
8936 built_actual_name != NULL,
8937 MODULE_DOMAIN, LOC_TYPEDEF,
8938 &objfile->global_psymbols,
8939 0, cu->language, objfile);
8941 case DW_TAG_class_type:
8942 case DW_TAG_interface_type:
8943 case DW_TAG_structure_type:
8944 case DW_TAG_union_type:
8945 case DW_TAG_enumeration_type:
8946 /* Skip external references. The DWARF standard says in the section
8947 about "Structure, Union, and Class Type Entries": "An incomplete
8948 structure, union or class type is represented by a structure,
8949 union or class entry that does not have a byte size attribute
8950 and that has a DW_AT_declaration attribute." */
8951 if (!pdi->has_byte_size && pdi->is_declaration)
8953 xfree (built_actual_name);
8957 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8958 static vs. global. */
8959 add_psymbol_to_list (actual_name, strlen (actual_name),
8960 built_actual_name != NULL,
8961 STRUCT_DOMAIN, LOC_TYPEDEF,
8962 cu->language == language_cplus
8963 ? &objfile->global_psymbols
8964 : &objfile->static_psymbols,
8965 0, cu->language, objfile);
8968 case DW_TAG_enumerator:
8969 add_psymbol_to_list (actual_name, strlen (actual_name),
8970 built_actual_name != NULL,
8971 VAR_DOMAIN, LOC_CONST,
8972 cu->language == language_cplus
8973 ? &objfile->global_psymbols
8974 : &objfile->static_psymbols,
8975 0, cu->language, objfile);
8981 xfree (built_actual_name);
8984 /* Read a partial die corresponding to a namespace; also, add a symbol
8985 corresponding to that namespace to the symbol table. NAMESPACE is
8986 the name of the enclosing namespace. */
8989 add_partial_namespace (struct partial_die_info *pdi,
8990 CORE_ADDR *lowpc, CORE_ADDR *highpc,
8991 int set_addrmap, struct dwarf2_cu *cu)
8993 /* Add a symbol for the namespace. */
8995 add_partial_symbol (pdi, cu);
8997 /* Now scan partial symbols in that namespace. */
8999 if (pdi->has_children)
9000 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9003 /* Read a partial die corresponding to a Fortran module. */
9006 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9007 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9009 /* Add a symbol for the namespace. */
9011 add_partial_symbol (pdi, cu);
9013 /* Now scan partial symbols in that module. */
9015 if (pdi->has_children)
9016 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9019 /* Read a partial die corresponding to a subprogram or an inlined
9020 subprogram and create a partial symbol for that subprogram.
9021 When the CU language allows it, this routine also defines a partial
9022 symbol for each nested subprogram that this subprogram contains.
9023 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9024 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9026 PDI may also be a lexical block, in which case we simply search
9027 recursively for subprograms defined inside that lexical block.
9028 Again, this is only performed when the CU language allows this
9029 type of definitions. */
9032 add_partial_subprogram (struct partial_die_info *pdi,
9033 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9034 int set_addrmap, struct dwarf2_cu *cu)
9036 if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9038 if (pdi->has_pc_info)
9040 if (pdi->lowpc < *lowpc)
9041 *lowpc = pdi->lowpc;
9042 if (pdi->highpc > *highpc)
9043 *highpc = pdi->highpc;
9046 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9047 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9052 baseaddr = ANOFFSET (objfile->section_offsets,
9053 SECT_OFF_TEXT (objfile));
9054 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch,
9055 pdi->lowpc + baseaddr);
9056 highpc = gdbarch_adjust_dwarf2_addr (gdbarch,
9057 pdi->highpc + baseaddr);
9058 addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
9059 cu->per_cu->v.psymtab);
9063 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9065 if (!pdi->is_declaration)
9066 /* Ignore subprogram DIEs that do not have a name, they are
9067 illegal. Do not emit a complaint at this point, we will
9068 do so when we convert this psymtab into a symtab. */
9070 add_partial_symbol (pdi, cu);
9074 if (! pdi->has_children)
9077 if (cu->language == language_ada)
9079 pdi = pdi->die_child;
9083 if (pdi->tag == DW_TAG_subprogram
9084 || pdi->tag == DW_TAG_inlined_subroutine
9085 || pdi->tag == DW_TAG_lexical_block)
9086 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9087 pdi = pdi->die_sibling;
9092 /* Read a partial die corresponding to an enumeration type. */
9095 add_partial_enumeration (struct partial_die_info *enum_pdi,
9096 struct dwarf2_cu *cu)
9098 struct partial_die_info *pdi;
9100 if (enum_pdi->name != NULL)
9101 add_partial_symbol (enum_pdi, cu);
9103 pdi = enum_pdi->die_child;
9106 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9107 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
9109 add_partial_symbol (pdi, cu);
9110 pdi = pdi->die_sibling;
9114 /* Return the initial uleb128 in the die at INFO_PTR. */
9117 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9119 unsigned int bytes_read;
9121 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9124 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9125 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9127 Return the corresponding abbrev, or NULL if the number is zero (indicating
9128 an empty DIE). In either case *BYTES_READ will be set to the length of
9129 the initial number. */
9131 static struct abbrev_info *
9132 peek_die_abbrev (const die_reader_specs &reader,
9133 const gdb_byte *info_ptr, unsigned int *bytes_read)
9135 dwarf2_cu *cu = reader.cu;
9136 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9137 unsigned int abbrev_number
9138 = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9140 if (abbrev_number == 0)
9143 abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9146 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9147 " at offset %s [in module %s]"),
9148 abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9149 sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9155 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9156 Returns a pointer to the end of a series of DIEs, terminated by an empty
9157 DIE. Any children of the skipped DIEs will also be skipped. */
9159 static const gdb_byte *
9160 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9164 unsigned int bytes_read;
9165 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9168 return info_ptr + bytes_read;
9170 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9174 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9175 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9176 abbrev corresponding to that skipped uleb128 should be passed in
9177 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9180 static const gdb_byte *
9181 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9182 struct abbrev_info *abbrev)
9184 unsigned int bytes_read;
9185 struct attribute attr;
9186 bfd *abfd = reader->abfd;
9187 struct dwarf2_cu *cu = reader->cu;
9188 const gdb_byte *buffer = reader->buffer;
9189 const gdb_byte *buffer_end = reader->buffer_end;
9190 unsigned int form, i;
9192 for (i = 0; i < abbrev->num_attrs; i++)
9194 /* The only abbrev we care about is DW_AT_sibling. */
9195 if (abbrev->attrs[i].name == DW_AT_sibling)
9197 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9198 if (attr.form == DW_FORM_ref_addr)
9199 complaint (&symfile_complaints,
9200 _("ignoring absolute DW_AT_sibling"));
9203 sect_offset off = dwarf2_get_ref_die_offset (&attr);
9204 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9206 if (sibling_ptr < info_ptr)
9207 complaint (&symfile_complaints,
9208 _("DW_AT_sibling points backwards"));
9209 else if (sibling_ptr > reader->buffer_end)
9210 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9216 /* If it isn't DW_AT_sibling, skip this attribute. */
9217 form = abbrev->attrs[i].form;
9221 case DW_FORM_ref_addr:
9222 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9223 and later it is offset sized. */
9224 if (cu->header.version == 2)
9225 info_ptr += cu->header.addr_size;
9227 info_ptr += cu->header.offset_size;
9229 case DW_FORM_GNU_ref_alt:
9230 info_ptr += cu->header.offset_size;
9233 info_ptr += cu->header.addr_size;
9240 case DW_FORM_flag_present:
9241 case DW_FORM_implicit_const:
9253 case DW_FORM_ref_sig8:
9256 case DW_FORM_data16:
9259 case DW_FORM_string:
9260 read_direct_string (abfd, info_ptr, &bytes_read);
9261 info_ptr += bytes_read;
9263 case DW_FORM_sec_offset:
9265 case DW_FORM_GNU_strp_alt:
9266 info_ptr += cu->header.offset_size;
9268 case DW_FORM_exprloc:
9270 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9271 info_ptr += bytes_read;
9273 case DW_FORM_block1:
9274 info_ptr += 1 + read_1_byte (abfd, info_ptr);
9276 case DW_FORM_block2:
9277 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9279 case DW_FORM_block4:
9280 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9284 case DW_FORM_ref_udata:
9285 case DW_FORM_GNU_addr_index:
9286 case DW_FORM_GNU_str_index:
9287 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9289 case DW_FORM_indirect:
9290 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9291 info_ptr += bytes_read;
9292 /* We need to continue parsing from here, so just go back to
9294 goto skip_attribute;
9297 error (_("Dwarf Error: Cannot handle %s "
9298 "in DWARF reader [in module %s]"),
9299 dwarf_form_name (form),
9300 bfd_get_filename (abfd));
9304 if (abbrev->has_children)
9305 return skip_children (reader, info_ptr);
9310 /* Locate ORIG_PDI's sibling.
9311 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9313 static const gdb_byte *
9314 locate_pdi_sibling (const struct die_reader_specs *reader,
9315 struct partial_die_info *orig_pdi,
9316 const gdb_byte *info_ptr)
9318 /* Do we know the sibling already? */
9320 if (orig_pdi->sibling)
9321 return orig_pdi->sibling;
9323 /* Are there any children to deal with? */
9325 if (!orig_pdi->has_children)
9328 /* Skip the children the long way. */
9330 return skip_children (reader, info_ptr);
9333 /* Expand this partial symbol table into a full symbol table. SELF is
9337 dwarf2_read_symtab (struct partial_symtab *self,
9338 struct objfile *objfile)
9340 struct dwarf2_per_objfile *dwarf2_per_objfile
9341 = get_dwarf2_per_objfile (objfile);
9345 warning (_("bug: psymtab for %s is already read in."),
9352 printf_filtered (_("Reading in symbols for %s..."),
9354 gdb_flush (gdb_stdout);
9357 /* If this psymtab is constructed from a debug-only objfile, the
9358 has_section_at_zero flag will not necessarily be correct. We
9359 can get the correct value for this flag by looking at the data
9360 associated with the (presumably stripped) associated objfile. */
9361 if (objfile->separate_debug_objfile_backlink)
9363 struct dwarf2_per_objfile *dpo_backlink
9364 = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9366 dwarf2_per_objfile->has_section_at_zero
9367 = dpo_backlink->has_section_at_zero;
9370 dwarf2_per_objfile->reading_partial_symbols = 0;
9372 psymtab_to_symtab_1 (self);
9374 /* Finish up the debug error message. */
9376 printf_filtered (_("done.\n"));
9379 process_cu_includes (dwarf2_per_objfile);
9382 /* Reading in full CUs. */
9384 /* Add PER_CU to the queue. */
9387 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9388 enum language pretend_language)
9390 struct dwarf2_queue_item *item;
9393 item = XNEW (struct dwarf2_queue_item);
9394 item->per_cu = per_cu;
9395 item->pretend_language = pretend_language;
9398 if (dwarf2_queue == NULL)
9399 dwarf2_queue = item;
9401 dwarf2_queue_tail->next = item;
9403 dwarf2_queue_tail = item;
9406 /* If PER_CU is not yet queued, add it to the queue.
9407 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9409 The result is non-zero if PER_CU was queued, otherwise the result is zero
9410 meaning either PER_CU is already queued or it is already loaded.
9412 N.B. There is an invariant here that if a CU is queued then it is loaded.
9413 The caller is required to load PER_CU if we return non-zero. */
9416 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9417 struct dwarf2_per_cu_data *per_cu,
9418 enum language pretend_language)
9420 /* We may arrive here during partial symbol reading, if we need full
9421 DIEs to process an unusual case (e.g. template arguments). Do
9422 not queue PER_CU, just tell our caller to load its DIEs. */
9423 if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9425 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9430 /* Mark the dependence relation so that we don't flush PER_CU
9432 if (dependent_cu != NULL)
9433 dwarf2_add_dependence (dependent_cu, per_cu);
9435 /* If it's already on the queue, we have nothing to do. */
9439 /* If the compilation unit is already loaded, just mark it as
9441 if (per_cu->cu != NULL)
9443 per_cu->cu->last_used = 0;
9447 /* Add it to the queue. */
9448 queue_comp_unit (per_cu, pretend_language);
9453 /* Process the queue. */
9456 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9458 struct dwarf2_queue_item *item, *next_item;
9460 if (dwarf_read_debug)
9462 fprintf_unfiltered (gdb_stdlog,
9463 "Expanding one or more symtabs of objfile %s ...\n",
9464 objfile_name (dwarf2_per_objfile->objfile));
9467 /* The queue starts out with one item, but following a DIE reference
9468 may load a new CU, adding it to the end of the queue. */
9469 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9471 if ((dwarf2_per_objfile->using_index
9472 ? !item->per_cu->v.quick->compunit_symtab
9473 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9474 /* Skip dummy CUs. */
9475 && item->per_cu->cu != NULL)
9477 struct dwarf2_per_cu_data *per_cu = item->per_cu;
9478 unsigned int debug_print_threshold;
9481 if (per_cu->is_debug_types)
9483 struct signatured_type *sig_type =
9484 (struct signatured_type *) per_cu;
9486 sprintf (buf, "TU %s at offset %s",
9487 hex_string (sig_type->signature),
9488 sect_offset_str (per_cu->sect_off));
9489 /* There can be 100s of TUs.
9490 Only print them in verbose mode. */
9491 debug_print_threshold = 2;
9495 sprintf (buf, "CU at offset %s",
9496 sect_offset_str (per_cu->sect_off));
9497 debug_print_threshold = 1;
9500 if (dwarf_read_debug >= debug_print_threshold)
9501 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9503 if (per_cu->is_debug_types)
9504 process_full_type_unit (per_cu, item->pretend_language);
9506 process_full_comp_unit (per_cu, item->pretend_language);
9508 if (dwarf_read_debug >= debug_print_threshold)
9509 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9512 item->per_cu->queued = 0;
9513 next_item = item->next;
9517 dwarf2_queue_tail = NULL;
9519 if (dwarf_read_debug)
9521 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9522 objfile_name (dwarf2_per_objfile->objfile));
9526 /* Read in full symbols for PST, and anything it depends on. */
9529 psymtab_to_symtab_1 (struct partial_symtab *pst)
9531 struct dwarf2_per_cu_data *per_cu;
9537 for (i = 0; i < pst->number_of_dependencies; i++)
9538 if (!pst->dependencies[i]->readin
9539 && pst->dependencies[i]->user == NULL)
9541 /* Inform about additional files that need to be read in. */
9544 /* FIXME: i18n: Need to make this a single string. */
9545 fputs_filtered (" ", gdb_stdout);
9547 fputs_filtered ("and ", gdb_stdout);
9549 printf_filtered ("%s...", pst->dependencies[i]->filename);
9550 wrap_here (""); /* Flush output. */
9551 gdb_flush (gdb_stdout);
9553 psymtab_to_symtab_1 (pst->dependencies[i]);
9556 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9560 /* It's an include file, no symbols to read for it.
9561 Everything is in the parent symtab. */
9566 dw2_do_instantiate_symtab (per_cu, false);
9569 /* Trivial hash function for die_info: the hash value of a DIE
9570 is its offset in .debug_info for this objfile. */
9573 die_hash (const void *item)
9575 const struct die_info *die = (const struct die_info *) item;
9577 return to_underlying (die->sect_off);
9580 /* Trivial comparison function for die_info structures: two DIEs
9581 are equal if they have the same offset. */
9584 die_eq (const void *item_lhs, const void *item_rhs)
9586 const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9587 const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9589 return die_lhs->sect_off == die_rhs->sect_off;
9592 /* die_reader_func for load_full_comp_unit.
9593 This is identical to read_signatured_type_reader,
9594 but is kept separate for now. */
9597 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9598 const gdb_byte *info_ptr,
9599 struct die_info *comp_unit_die,
9603 struct dwarf2_cu *cu = reader->cu;
9604 enum language *language_ptr = (enum language *) data;
9606 gdb_assert (cu->die_hash == NULL);
9608 htab_create_alloc_ex (cu->header.length / 12,
9612 &cu->comp_unit_obstack,
9613 hashtab_obstack_allocate,
9614 dummy_obstack_deallocate);
9617 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9618 &info_ptr, comp_unit_die);
9619 cu->dies = comp_unit_die;
9620 /* comp_unit_die is not stored in die_hash, no need. */
9622 /* We try not to read any attributes in this function, because not
9623 all CUs needed for references have been loaded yet, and symbol
9624 table processing isn't initialized. But we have to set the CU language,
9625 or we won't be able to build types correctly.
9626 Similarly, if we do not read the producer, we can not apply
9627 producer-specific interpretation. */
9628 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9631 /* Load the DIEs associated with PER_CU into memory. */
9634 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9636 enum language pretend_language)
9638 gdb_assert (! this_cu->is_debug_types);
9640 init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9641 load_full_comp_unit_reader, &pretend_language);
9644 /* Add a DIE to the delayed physname list. */
9647 add_to_method_list (struct type *type, int fnfield_index, int index,
9648 const char *name, struct die_info *die,
9649 struct dwarf2_cu *cu)
9651 struct delayed_method_info mi;
9653 mi.fnfield_index = fnfield_index;
9657 cu->method_list.push_back (mi);
9660 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9661 "const" / "volatile". If so, decrements LEN by the length of the
9662 modifier and return true. Otherwise return false. */
9666 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9668 size_t mod_len = sizeof (mod) - 1;
9669 if (len > mod_len && startswith (physname + (len - mod_len), mod))
9677 /* Compute the physnames of any methods on the CU's method list.
9679 The computation of method physnames is delayed in order to avoid the
9680 (bad) condition that one of the method's formal parameters is of an as yet
9684 compute_delayed_physnames (struct dwarf2_cu *cu)
9686 /* Only C++ delays computing physnames. */
9687 if (cu->method_list.empty ())
9689 gdb_assert (cu->language == language_cplus);
9691 for (struct delayed_method_info &mi : cu->method_list)
9693 const char *physname;
9694 struct fn_fieldlist *fn_flp
9695 = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9696 physname = dwarf2_physname (mi.name, mi.die, cu);
9697 TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9698 = physname ? physname : "";
9700 /* Since there's no tag to indicate whether a method is a
9701 const/volatile overload, extract that information out of the
9703 if (physname != NULL)
9705 size_t len = strlen (physname);
9709 if (physname[len] == ')') /* shortcut */
9711 else if (check_modifier (physname, len, " const"))
9712 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9713 else if (check_modifier (physname, len, " volatile"))
9714 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9721 /* The list is no longer needed. */
9722 cu->method_list.clear ();
9725 /* Go objects should be embedded in a DW_TAG_module DIE,
9726 and it's not clear if/how imported objects will appear.
9727 To keep Go support simple until that's worked out,
9728 go back through what we've read and create something usable.
9729 We could do this while processing each DIE, and feels kinda cleaner,
9730 but that way is more invasive.
9731 This is to, for example, allow the user to type "p var" or "b main"
9732 without having to specify the package name, and allow lookups
9733 of module.object to work in contexts that use the expression
9737 fixup_go_packaging (struct dwarf2_cu *cu)
9739 char *package_name = NULL;
9740 struct pending *list;
9743 for (list = global_symbols; list != NULL; list = list->next)
9745 for (i = 0; i < list->nsyms; ++i)
9747 struct symbol *sym = list->symbol[i];
9749 if (SYMBOL_LANGUAGE (sym) == language_go
9750 && SYMBOL_CLASS (sym) == LOC_BLOCK)
9752 char *this_package_name = go_symbol_package_name (sym);
9754 if (this_package_name == NULL)
9756 if (package_name == NULL)
9757 package_name = this_package_name;
9760 struct objfile *objfile
9761 = cu->per_cu->dwarf2_per_objfile->objfile;
9762 if (strcmp (package_name, this_package_name) != 0)
9763 complaint (&symfile_complaints,
9764 _("Symtab %s has objects from two different Go packages: %s and %s"),
9765 (symbol_symtab (sym) != NULL
9766 ? symtab_to_filename_for_display
9767 (symbol_symtab (sym))
9768 : objfile_name (objfile)),
9769 this_package_name, package_name);
9770 xfree (this_package_name);
9776 if (package_name != NULL)
9778 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9779 const char *saved_package_name
9780 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9782 strlen (package_name));
9783 struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9784 saved_package_name);
9787 TYPE_TAG_NAME (type) = TYPE_NAME (type);
9789 sym = allocate_symbol (objfile);
9790 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9791 SYMBOL_SET_NAMES (sym, saved_package_name,
9792 strlen (saved_package_name), 0, objfile);
9793 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9794 e.g., "main" finds the "main" module and not C's main(). */
9795 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9796 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9797 SYMBOL_TYPE (sym) = type;
9799 add_symbol_to_list (sym, &global_symbols);
9801 xfree (package_name);
9805 /* Allocate a fully-qualified name consisting of the two parts on the
9809 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9811 return obconcat (obstack, p1, "::", p2, (char *) NULL);
9814 /* A helper that allocates a struct discriminant_info to attach to a
9817 static struct discriminant_info *
9818 alloc_discriminant_info (struct type *type, int discriminant_index,
9821 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9822 gdb_assert (discriminant_index == -1
9823 || (discriminant_index >= 0
9824 && discriminant_index < TYPE_NFIELDS (type)));
9825 gdb_assert (default_index == -1
9826 || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9828 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9830 struct discriminant_info *disc
9831 = ((struct discriminant_info *)
9833 offsetof (struct discriminant_info, discriminants)
9834 + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9835 disc->default_index = default_index;
9836 disc->discriminant_index = discriminant_index;
9838 struct dynamic_prop prop;
9839 prop.kind = PROP_UNDEFINED;
9840 prop.data.baton = disc;
9842 add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9847 /* Some versions of rustc emitted enums in an unusual way.
9849 Ordinary enums were emitted as unions. The first element of each
9850 structure in the union was named "RUST$ENUM$DISR". This element
9851 held the discriminant.
9853 These versions of Rust also implemented the "non-zero"
9854 optimization. When the enum had two values, and one is empty and
9855 the other holds a pointer that cannot be zero, the pointer is used
9856 as the discriminant, with a zero value meaning the empty variant.
9857 Here, the union's first member is of the form
9858 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9859 where the fieldnos are the indices of the fields that should be
9860 traversed in order to find the field (which may be several fields deep)
9861 and the variantname is the name of the variant of the case when the
9864 This function recognizes whether TYPE is of one of these forms,
9865 and, if so, smashes it to be a variant type. */
9868 quirk_rust_enum (struct type *type, struct objfile *objfile)
9870 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9872 /* We don't need to deal with empty enums. */
9873 if (TYPE_NFIELDS (type) == 0)
9876 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9877 if (TYPE_NFIELDS (type) == 1
9878 && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9880 const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9882 /* Decode the field name to find the offset of the
9884 ULONGEST bit_offset = 0;
9885 struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9886 while (name[0] >= '0' && name[0] <= '9')
9889 unsigned long index = strtoul (name, &tail, 10);
9892 || index >= TYPE_NFIELDS (field_type)
9893 || (TYPE_FIELD_LOC_KIND (field_type, index)
9894 != FIELD_LOC_KIND_BITPOS))
9896 complaint (&symfile_complaints,
9897 _("Could not parse Rust enum encoding string \"%s\""
9899 TYPE_FIELD_NAME (type, 0),
9900 objfile_name (objfile));
9905 bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9906 field_type = TYPE_FIELD_TYPE (field_type, index);
9909 /* Make a union to hold the variants. */
9910 struct type *union_type = alloc_type (objfile);
9911 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9912 TYPE_NFIELDS (union_type) = 3;
9913 TYPE_FIELDS (union_type)
9914 = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
9915 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9916 set_type_align (union_type, TYPE_RAW_ALIGN (type));
9918 /* Put the discriminant must at index 0. */
9919 TYPE_FIELD_TYPE (union_type, 0) = field_type;
9920 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
9921 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
9922 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
9924 /* The order of fields doesn't really matter, so put the real
9925 field at index 1 and the data-less field at index 2. */
9926 struct discriminant_info *disc
9927 = alloc_discriminant_info (union_type, 0, 1);
9928 TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
9929 TYPE_FIELD_NAME (union_type, 1)
9930 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
9931 TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
9932 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
9933 TYPE_FIELD_NAME (union_type, 1));
9935 const char *dataless_name
9936 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
9938 struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
9940 TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
9941 /* NAME points into the original discriminant name, which
9942 already has the correct lifetime. */
9943 TYPE_FIELD_NAME (union_type, 2) = name;
9944 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
9945 disc->discriminants[2] = 0;
9947 /* Smash this type to be a structure type. We have to do this
9948 because the type has already been recorded. */
9949 TYPE_CODE (type) = TYPE_CODE_STRUCT;
9950 TYPE_NFIELDS (type) = 1;
9952 = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
9954 /* Install the variant part. */
9955 TYPE_FIELD_TYPE (type, 0) = union_type;
9956 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
9957 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
9959 else if (TYPE_NFIELDS (type) == 1)
9961 /* We assume that a union with a single field is a univariant
9963 /* Smash this type to be a structure type. We have to do this
9964 because the type has already been recorded. */
9965 TYPE_CODE (type) = TYPE_CODE_STRUCT;
9967 /* Make a union to hold the variants. */
9968 struct type *union_type = alloc_type (objfile);
9969 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9970 TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
9971 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9972 set_type_align (union_type, TYPE_RAW_ALIGN (type));
9973 TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
9975 struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
9976 const char *variant_name
9977 = rust_last_path_segment (TYPE_NAME (field_type));
9978 TYPE_FIELD_NAME (union_type, 0) = variant_name;
9979 TYPE_NAME (field_type)
9980 = rust_fully_qualify (&objfile->objfile_obstack,
9981 TYPE_NAME (type), variant_name);
9983 /* Install the union in the outer struct type. */
9984 TYPE_NFIELDS (type) = 1;
9986 = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
9987 TYPE_FIELD_TYPE (type, 0) = union_type;
9988 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
9989 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
9991 alloc_discriminant_info (union_type, -1, 0);
9995 struct type *disr_type = nullptr;
9996 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
9998 disr_type = TYPE_FIELD_TYPE (type, i);
10000 if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10002 /* All fields of a true enum will be structs. */
10005 else if (TYPE_NFIELDS (disr_type) == 0)
10007 /* Could be data-less variant, so keep going. */
10008 disr_type = nullptr;
10010 else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10011 "RUST$ENUM$DISR") != 0)
10013 /* Not a Rust enum. */
10023 /* If we got here without a discriminant, then it's probably
10025 if (disr_type == nullptr)
10028 /* Smash this type to be a structure type. We have to do this
10029 because the type has already been recorded. */
10030 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10032 /* Make a union to hold the variants. */
10033 struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10034 struct type *union_type = alloc_type (objfile);
10035 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10036 TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10037 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10038 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10039 TYPE_FIELDS (union_type)
10040 = (struct field *) TYPE_ZALLOC (union_type,
10041 (TYPE_NFIELDS (union_type)
10042 * sizeof (struct field)));
10044 memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10045 TYPE_NFIELDS (type) * sizeof (struct field));
10047 /* Install the discriminant at index 0 in the union. */
10048 TYPE_FIELD (union_type, 0) = *disr_field;
10049 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10050 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10052 /* Install the union in the outer struct type. */
10053 TYPE_FIELD_TYPE (type, 0) = union_type;
10054 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10055 TYPE_NFIELDS (type) = 1;
10057 /* Set the size and offset of the union type. */
10058 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10060 /* We need a way to find the correct discriminant given a
10061 variant name. For convenience we build a map here. */
10062 struct type *enum_type = FIELD_TYPE (*disr_field);
10063 std::unordered_map<std::string, ULONGEST> discriminant_map;
10064 for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10066 if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10069 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10070 discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10074 int n_fields = TYPE_NFIELDS (union_type);
10075 struct discriminant_info *disc
10076 = alloc_discriminant_info (union_type, 0, -1);
10077 /* Skip the discriminant here. */
10078 for (int i = 1; i < n_fields; ++i)
10080 /* Find the final word in the name of this variant's type.
10081 That name can be used to look up the correct
10083 const char *variant_name
10084 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10087 auto iter = discriminant_map.find (variant_name);
10088 if (iter != discriminant_map.end ())
10089 disc->discriminants[i] = iter->second;
10091 /* Remove the discriminant field, if it exists. */
10092 struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10093 if (TYPE_NFIELDS (sub_type) > 0)
10095 --TYPE_NFIELDS (sub_type);
10096 ++TYPE_FIELDS (sub_type);
10098 TYPE_FIELD_NAME (union_type, i) = variant_name;
10099 TYPE_NAME (sub_type)
10100 = rust_fully_qualify (&objfile->objfile_obstack,
10101 TYPE_NAME (type), variant_name);
10106 /* Rewrite some Rust unions to be structures with variants parts. */
10109 rust_union_quirks (struct dwarf2_cu *cu)
10111 gdb_assert (cu->language == language_rust);
10112 for (struct type *type : cu->rust_unions)
10113 quirk_rust_enum (type, cu->per_cu->dwarf2_per_objfile->objfile);
10114 /* We don't need this any more. */
10115 cu->rust_unions.clear ();
10118 /* Return the symtab for PER_CU. This works properly regardless of
10119 whether we're using the index or psymtabs. */
10121 static struct compunit_symtab *
10122 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10124 return (per_cu->dwarf2_per_objfile->using_index
10125 ? per_cu->v.quick->compunit_symtab
10126 : per_cu->v.psymtab->compunit_symtab);
10129 /* A helper function for computing the list of all symbol tables
10130 included by PER_CU. */
10133 recursively_compute_inclusions (VEC (compunit_symtab_ptr) **result,
10134 htab_t all_children, htab_t all_type_symtabs,
10135 struct dwarf2_per_cu_data *per_cu,
10136 struct compunit_symtab *immediate_parent)
10140 struct compunit_symtab *cust;
10141 struct dwarf2_per_cu_data *iter;
10143 slot = htab_find_slot (all_children, per_cu, INSERT);
10146 /* This inclusion and its children have been processed. */
10151 /* Only add a CU if it has a symbol table. */
10152 cust = get_compunit_symtab (per_cu);
10155 /* If this is a type unit only add its symbol table if we haven't
10156 seen it yet (type unit per_cu's can share symtabs). */
10157 if (per_cu->is_debug_types)
10159 slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10163 VEC_safe_push (compunit_symtab_ptr, *result, cust);
10164 if (cust->user == NULL)
10165 cust->user = immediate_parent;
10170 VEC_safe_push (compunit_symtab_ptr, *result, cust);
10171 if (cust->user == NULL)
10172 cust->user = immediate_parent;
10177 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10180 recursively_compute_inclusions (result, all_children,
10181 all_type_symtabs, iter, cust);
10185 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10189 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10191 gdb_assert (! per_cu->is_debug_types);
10193 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10196 struct dwarf2_per_cu_data *per_cu_iter;
10197 struct compunit_symtab *compunit_symtab_iter;
10198 VEC (compunit_symtab_ptr) *result_symtabs = NULL;
10199 htab_t all_children, all_type_symtabs;
10200 struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10202 /* If we don't have a symtab, we can just skip this case. */
10206 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10207 NULL, xcalloc, xfree);
10208 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10209 NULL, xcalloc, xfree);
10212 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10216 recursively_compute_inclusions (&result_symtabs, all_children,
10217 all_type_symtabs, per_cu_iter,
10221 /* Now we have a transitive closure of all the included symtabs. */
10222 len = VEC_length (compunit_symtab_ptr, result_symtabs);
10224 = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10225 struct compunit_symtab *, len + 1);
10227 VEC_iterate (compunit_symtab_ptr, result_symtabs, ix,
10228 compunit_symtab_iter);
10230 cust->includes[ix] = compunit_symtab_iter;
10231 cust->includes[len] = NULL;
10233 VEC_free (compunit_symtab_ptr, result_symtabs);
10234 htab_delete (all_children);
10235 htab_delete (all_type_symtabs);
10239 /* Compute the 'includes' field for the symtabs of all the CUs we just
10243 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10246 struct dwarf2_per_cu_data *iter;
10249 VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
10253 if (! iter->is_debug_types)
10254 compute_compunit_symtab_includes (iter);
10257 VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
10260 /* Generate full symbol information for PER_CU, whose DIEs have
10261 already been loaded into memory. */
10264 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10265 enum language pretend_language)
10267 struct dwarf2_cu *cu = per_cu->cu;
10268 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10269 struct objfile *objfile = dwarf2_per_objfile->objfile;
10270 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10271 CORE_ADDR lowpc, highpc;
10272 struct compunit_symtab *cust;
10273 CORE_ADDR baseaddr;
10274 struct block *static_block;
10277 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10280 scoped_free_pendings free_pending;
10282 /* Clear the list here in case something was left over. */
10283 cu->method_list.clear ();
10285 cu->list_in_scope = &file_symbols;
10287 cu->language = pretend_language;
10288 cu->language_defn = language_def (cu->language);
10290 /* Do line number decoding in read_file_scope () */
10291 process_die (cu->dies, cu);
10293 /* For now fudge the Go package. */
10294 if (cu->language == language_go)
10295 fixup_go_packaging (cu);
10297 /* Now that we have processed all the DIEs in the CU, all the types
10298 should be complete, and it should now be safe to compute all of the
10300 compute_delayed_physnames (cu);
10302 if (cu->language == language_rust)
10303 rust_union_quirks (cu);
10305 /* Some compilers don't define a DW_AT_high_pc attribute for the
10306 compilation unit. If the DW_AT_high_pc is missing, synthesize
10307 it, by scanning the DIE's below the compilation unit. */
10308 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10310 addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10311 static_block = end_symtab_get_static_block (addr, 0, 1);
10313 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10314 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10315 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10316 addrmap to help ensure it has an accurate map of pc values belonging to
10318 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10320 cust = end_symtab_from_static_block (static_block,
10321 SECT_OFF_TEXT (objfile), 0);
10325 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10327 /* Set symtab language to language from DW_AT_language. If the
10328 compilation is from a C file generated by language preprocessors, do
10329 not set the language if it was already deduced by start_subfile. */
10330 if (!(cu->language == language_c
10331 && COMPUNIT_FILETABS (cust)->language != language_unknown))
10332 COMPUNIT_FILETABS (cust)->language = cu->language;
10334 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10335 produce DW_AT_location with location lists but it can be possibly
10336 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10337 there were bugs in prologue debug info, fixed later in GCC-4.5
10338 by "unwind info for epilogues" patch (which is not directly related).
10340 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10341 needed, it would be wrong due to missing DW_AT_producer there.
10343 Still one can confuse GDB by using non-standard GCC compilation
10344 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10346 if (cu->has_loclist && gcc_4_minor >= 5)
10347 cust->locations_valid = 1;
10349 if (gcc_4_minor >= 5)
10350 cust->epilogue_unwind_valid = 1;
10352 cust->call_site_htab = cu->call_site_htab;
10355 if (dwarf2_per_objfile->using_index)
10356 per_cu->v.quick->compunit_symtab = cust;
10359 struct partial_symtab *pst = per_cu->v.psymtab;
10360 pst->compunit_symtab = cust;
10364 /* Push it for inclusion processing later. */
10365 VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
10368 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10369 already been loaded into memory. */
10372 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10373 enum language pretend_language)
10375 struct dwarf2_cu *cu = per_cu->cu;
10376 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10377 struct objfile *objfile = dwarf2_per_objfile->objfile;
10378 struct compunit_symtab *cust;
10379 struct signatured_type *sig_type;
10381 gdb_assert (per_cu->is_debug_types);
10382 sig_type = (struct signatured_type *) per_cu;
10385 scoped_free_pendings free_pending;
10387 /* Clear the list here in case something was left over. */
10388 cu->method_list.clear ();
10390 cu->list_in_scope = &file_symbols;
10392 cu->language = pretend_language;
10393 cu->language_defn = language_def (cu->language);
10395 /* The symbol tables are set up in read_type_unit_scope. */
10396 process_die (cu->dies, cu);
10398 /* For now fudge the Go package. */
10399 if (cu->language == language_go)
10400 fixup_go_packaging (cu);
10402 /* Now that we have processed all the DIEs in the CU, all the types
10403 should be complete, and it should now be safe to compute all of the
10405 compute_delayed_physnames (cu);
10407 if (cu->language == language_rust)
10408 rust_union_quirks (cu);
10410 /* TUs share symbol tables.
10411 If this is the first TU to use this symtab, complete the construction
10412 of it with end_expandable_symtab. Otherwise, complete the addition of
10413 this TU's symbols to the existing symtab. */
10414 if (sig_type->type_unit_group->compunit_symtab == NULL)
10416 cust = end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10417 sig_type->type_unit_group->compunit_symtab = cust;
10421 /* Set symtab language to language from DW_AT_language. If the
10422 compilation is from a C file generated by language preprocessors,
10423 do not set the language if it was already deduced by
10425 if (!(cu->language == language_c
10426 && COMPUNIT_FILETABS (cust)->language != language_c))
10427 COMPUNIT_FILETABS (cust)->language = cu->language;
10432 augment_type_symtab ();
10433 cust = sig_type->type_unit_group->compunit_symtab;
10436 if (dwarf2_per_objfile->using_index)
10437 per_cu->v.quick->compunit_symtab = cust;
10440 struct partial_symtab *pst = per_cu->v.psymtab;
10441 pst->compunit_symtab = cust;
10446 /* Process an imported unit DIE. */
10449 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10451 struct attribute *attr;
10453 /* For now we don't handle imported units in type units. */
10454 if (cu->per_cu->is_debug_types)
10456 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10457 " supported in type units [in module %s]"),
10458 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10461 attr = dwarf2_attr (die, DW_AT_import, cu);
10464 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10465 bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10466 dwarf2_per_cu_data *per_cu
10467 = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10468 cu->per_cu->dwarf2_per_objfile);
10470 /* If necessary, add it to the queue and load its DIEs. */
10471 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10472 load_full_comp_unit (per_cu, false, cu->language);
10474 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10479 /* RAII object that represents a process_die scope: i.e.,
10480 starts/finishes processing a DIE. */
10481 class process_die_scope
10484 process_die_scope (die_info *die, dwarf2_cu *cu)
10485 : m_die (die), m_cu (cu)
10487 /* We should only be processing DIEs not already in process. */
10488 gdb_assert (!m_die->in_process);
10489 m_die->in_process = true;
10492 ~process_die_scope ()
10494 m_die->in_process = false;
10496 /* If we're done processing the DIE for the CU that owns the line
10497 header, we don't need the line header anymore. */
10498 if (m_cu->line_header_die_owner == m_die)
10500 delete m_cu->line_header;
10501 m_cu->line_header = NULL;
10502 m_cu->line_header_die_owner = NULL;
10511 /* Process a die and its children. */
10514 process_die (struct die_info *die, struct dwarf2_cu *cu)
10516 process_die_scope scope (die, cu);
10520 case DW_TAG_padding:
10522 case DW_TAG_compile_unit:
10523 case DW_TAG_partial_unit:
10524 read_file_scope (die, cu);
10526 case DW_TAG_type_unit:
10527 read_type_unit_scope (die, cu);
10529 case DW_TAG_subprogram:
10530 case DW_TAG_inlined_subroutine:
10531 read_func_scope (die, cu);
10533 case DW_TAG_lexical_block:
10534 case DW_TAG_try_block:
10535 case DW_TAG_catch_block:
10536 read_lexical_block_scope (die, cu);
10538 case DW_TAG_call_site:
10539 case DW_TAG_GNU_call_site:
10540 read_call_site_scope (die, cu);
10542 case DW_TAG_class_type:
10543 case DW_TAG_interface_type:
10544 case DW_TAG_structure_type:
10545 case DW_TAG_union_type:
10546 process_structure_scope (die, cu);
10548 case DW_TAG_enumeration_type:
10549 process_enumeration_scope (die, cu);
10552 /* These dies have a type, but processing them does not create
10553 a symbol or recurse to process the children. Therefore we can
10554 read them on-demand through read_type_die. */
10555 case DW_TAG_subroutine_type:
10556 case DW_TAG_set_type:
10557 case DW_TAG_array_type:
10558 case DW_TAG_pointer_type:
10559 case DW_TAG_ptr_to_member_type:
10560 case DW_TAG_reference_type:
10561 case DW_TAG_rvalue_reference_type:
10562 case DW_TAG_string_type:
10565 case DW_TAG_base_type:
10566 case DW_TAG_subrange_type:
10567 case DW_TAG_typedef:
10568 /* Add a typedef symbol for the type definition, if it has a
10570 new_symbol (die, read_type_die (die, cu), cu);
10572 case DW_TAG_common_block:
10573 read_common_block (die, cu);
10575 case DW_TAG_common_inclusion:
10577 case DW_TAG_namespace:
10578 cu->processing_has_namespace_info = 1;
10579 read_namespace (die, cu);
10581 case DW_TAG_module:
10582 cu->processing_has_namespace_info = 1;
10583 read_module (die, cu);
10585 case DW_TAG_imported_declaration:
10586 cu->processing_has_namespace_info = 1;
10587 if (read_namespace_alias (die, cu))
10589 /* The declaration is not a global namespace alias. */
10590 /* Fall through. */
10591 case DW_TAG_imported_module:
10592 cu->processing_has_namespace_info = 1;
10593 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10594 || cu->language != language_fortran))
10595 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
10596 dwarf_tag_name (die->tag));
10597 read_import_statement (die, cu);
10600 case DW_TAG_imported_unit:
10601 process_imported_unit_die (die, cu);
10604 case DW_TAG_variable:
10605 read_variable (die, cu);
10609 new_symbol (die, NULL, cu);
10614 /* DWARF name computation. */
10616 /* A helper function for dwarf2_compute_name which determines whether DIE
10617 needs to have the name of the scope prepended to the name listed in the
10621 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10623 struct attribute *attr;
10627 case DW_TAG_namespace:
10628 case DW_TAG_typedef:
10629 case DW_TAG_class_type:
10630 case DW_TAG_interface_type:
10631 case DW_TAG_structure_type:
10632 case DW_TAG_union_type:
10633 case DW_TAG_enumeration_type:
10634 case DW_TAG_enumerator:
10635 case DW_TAG_subprogram:
10636 case DW_TAG_inlined_subroutine:
10637 case DW_TAG_member:
10638 case DW_TAG_imported_declaration:
10641 case DW_TAG_variable:
10642 case DW_TAG_constant:
10643 /* We only need to prefix "globally" visible variables. These include
10644 any variable marked with DW_AT_external or any variable that
10645 lives in a namespace. [Variables in anonymous namespaces
10646 require prefixing, but they are not DW_AT_external.] */
10648 if (dwarf2_attr (die, DW_AT_specification, cu))
10650 struct dwarf2_cu *spec_cu = cu;
10652 return die_needs_namespace (die_specification (die, &spec_cu),
10656 attr = dwarf2_attr (die, DW_AT_external, cu);
10657 if (attr == NULL && die->parent->tag != DW_TAG_namespace
10658 && die->parent->tag != DW_TAG_module)
10660 /* A variable in a lexical block of some kind does not need a
10661 namespace, even though in C++ such variables may be external
10662 and have a mangled name. */
10663 if (die->parent->tag == DW_TAG_lexical_block
10664 || die->parent->tag == DW_TAG_try_block
10665 || die->parent->tag == DW_TAG_catch_block
10666 || die->parent->tag == DW_TAG_subprogram)
10675 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10676 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10677 defined for the given DIE. */
10679 static struct attribute *
10680 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10682 struct attribute *attr;
10684 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10686 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10691 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10692 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10693 defined for the given DIE. */
10695 static const char *
10696 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10698 const char *linkage_name;
10700 linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10701 if (linkage_name == NULL)
10702 linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10704 return linkage_name;
10707 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10708 compute the physname for the object, which include a method's:
10709 - formal parameters (C++),
10710 - receiver type (Go),
10712 The term "physname" is a bit confusing.
10713 For C++, for example, it is the demangled name.
10714 For Go, for example, it's the mangled name.
10716 For Ada, return the DIE's linkage name rather than the fully qualified
10717 name. PHYSNAME is ignored..
10719 The result is allocated on the objfile_obstack and canonicalized. */
10721 static const char *
10722 dwarf2_compute_name (const char *name,
10723 struct die_info *die, struct dwarf2_cu *cu,
10726 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10729 name = dwarf2_name (die, cu);
10731 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10732 but otherwise compute it by typename_concat inside GDB.
10733 FIXME: Actually this is not really true, or at least not always true.
10734 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10735 Fortran names because there is no mangling standard. So new_symbol
10736 will set the demangled name to the result of dwarf2_full_name, and it is
10737 the demangled name that GDB uses if it exists. */
10738 if (cu->language == language_ada
10739 || (cu->language == language_fortran && physname))
10741 /* For Ada unit, we prefer the linkage name over the name, as
10742 the former contains the exported name, which the user expects
10743 to be able to reference. Ideally, we want the user to be able
10744 to reference this entity using either natural or linkage name,
10745 but we haven't started looking at this enhancement yet. */
10746 const char *linkage_name = dw2_linkage_name (die, cu);
10748 if (linkage_name != NULL)
10749 return linkage_name;
10752 /* These are the only languages we know how to qualify names in. */
10754 && (cu->language == language_cplus
10755 || cu->language == language_fortran || cu->language == language_d
10756 || cu->language == language_rust))
10758 if (die_needs_namespace (die, cu))
10760 const char *prefix;
10761 const char *canonical_name = NULL;
10765 prefix = determine_prefix (die, cu);
10766 if (*prefix != '\0')
10768 char *prefixed_name = typename_concat (NULL, prefix, name,
10771 buf.puts (prefixed_name);
10772 xfree (prefixed_name);
10777 /* Template parameters may be specified in the DIE's DW_AT_name, or
10778 as children with DW_TAG_template_type_param or
10779 DW_TAG_value_type_param. If the latter, add them to the name
10780 here. If the name already has template parameters, then
10781 skip this step; some versions of GCC emit both, and
10782 it is more efficient to use the pre-computed name.
10784 Something to keep in mind about this process: it is very
10785 unlikely, or in some cases downright impossible, to produce
10786 something that will match the mangled name of a function.
10787 If the definition of the function has the same debug info,
10788 we should be able to match up with it anyway. But fallbacks
10789 using the minimal symbol, for instance to find a method
10790 implemented in a stripped copy of libstdc++, will not work.
10791 If we do not have debug info for the definition, we will have to
10792 match them up some other way.
10794 When we do name matching there is a related problem with function
10795 templates; two instantiated function templates are allowed to
10796 differ only by their return types, which we do not add here. */
10798 if (cu->language == language_cplus && strchr (name, '<') == NULL)
10800 struct attribute *attr;
10801 struct die_info *child;
10804 die->building_fullname = 1;
10806 for (child = die->child; child != NULL; child = child->sibling)
10810 const gdb_byte *bytes;
10811 struct dwarf2_locexpr_baton *baton;
10814 if (child->tag != DW_TAG_template_type_param
10815 && child->tag != DW_TAG_template_value_param)
10826 attr = dwarf2_attr (child, DW_AT_type, cu);
10829 complaint (&symfile_complaints,
10830 _("template parameter missing DW_AT_type"));
10831 buf.puts ("UNKNOWN_TYPE");
10834 type = die_type (child, cu);
10836 if (child->tag == DW_TAG_template_type_param)
10838 c_print_type (type, "", &buf, -1, 0, &type_print_raw_options);
10842 attr = dwarf2_attr (child, DW_AT_const_value, cu);
10845 complaint (&symfile_complaints,
10846 _("template parameter missing "
10847 "DW_AT_const_value"));
10848 buf.puts ("UNKNOWN_VALUE");
10852 dwarf2_const_value_attr (attr, type, name,
10853 &cu->comp_unit_obstack, cu,
10854 &value, &bytes, &baton);
10856 if (TYPE_NOSIGN (type))
10857 /* GDB prints characters as NUMBER 'CHAR'. If that's
10858 changed, this can use value_print instead. */
10859 c_printchar (value, type, &buf);
10862 struct value_print_options opts;
10865 v = dwarf2_evaluate_loc_desc (type, NULL,
10869 else if (bytes != NULL)
10871 v = allocate_value (type);
10872 memcpy (value_contents_writeable (v), bytes,
10873 TYPE_LENGTH (type));
10876 v = value_from_longest (type, value);
10878 /* Specify decimal so that we do not depend on
10880 get_formatted_print_options (&opts, 'd');
10882 value_print (v, &buf, &opts);
10887 die->building_fullname = 0;
10891 /* Close the argument list, with a space if necessary
10892 (nested templates). */
10893 if (!buf.empty () && buf.string ().back () == '>')
10900 /* For C++ methods, append formal parameter type
10901 information, if PHYSNAME. */
10903 if (physname && die->tag == DW_TAG_subprogram
10904 && cu->language == language_cplus)
10906 struct type *type = read_type_die (die, cu);
10908 c_type_print_args (type, &buf, 1, cu->language,
10909 &type_print_raw_options);
10911 if (cu->language == language_cplus)
10913 /* Assume that an artificial first parameter is
10914 "this", but do not crash if it is not. RealView
10915 marks unnamed (and thus unused) parameters as
10916 artificial; there is no way to differentiate
10918 if (TYPE_NFIELDS (type) > 0
10919 && TYPE_FIELD_ARTIFICIAL (type, 0)
10920 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10921 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10923 buf.puts (" const");
10927 const std::string &intermediate_name = buf.string ();
10929 if (cu->language == language_cplus)
10931 = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
10932 &objfile->per_bfd->storage_obstack);
10934 /* If we only computed INTERMEDIATE_NAME, or if
10935 INTERMEDIATE_NAME is already canonical, then we need to
10936 copy it to the appropriate obstack. */
10937 if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
10938 name = ((const char *)
10939 obstack_copy0 (&objfile->per_bfd->storage_obstack,
10940 intermediate_name.c_str (),
10941 intermediate_name.length ()));
10943 name = canonical_name;
10950 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10951 If scope qualifiers are appropriate they will be added. The result
10952 will be allocated on the storage_obstack, or NULL if the DIE does
10953 not have a name. NAME may either be from a previous call to
10954 dwarf2_name or NULL.
10956 The output string will be canonicalized (if C++). */
10958 static const char *
10959 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
10961 return dwarf2_compute_name (name, die, cu, 0);
10964 /* Construct a physname for the given DIE in CU. NAME may either be
10965 from a previous call to dwarf2_name or NULL. The result will be
10966 allocated on the objfile_objstack or NULL if the DIE does not have a
10969 The output string will be canonicalized (if C++). */
10971 static const char *
10972 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
10974 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10975 const char *retval, *mangled = NULL, *canon = NULL;
10978 /* In this case dwarf2_compute_name is just a shortcut not building anything
10980 if (!die_needs_namespace (die, cu))
10981 return dwarf2_compute_name (name, die, cu, 1);
10983 mangled = dw2_linkage_name (die, cu);
10985 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10986 See https://github.com/rust-lang/rust/issues/32925. */
10987 if (cu->language == language_rust && mangled != NULL
10988 && strchr (mangled, '{') != NULL)
10991 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10993 gdb::unique_xmalloc_ptr<char> demangled;
10994 if (mangled != NULL)
10997 if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
10999 /* Do nothing (do not demangle the symbol name). */
11001 else if (cu->language == language_go)
11003 /* This is a lie, but we already lie to the caller new_symbol.
11004 new_symbol assumes we return the mangled name.
11005 This just undoes that lie until things are cleaned up. */
11009 /* Use DMGL_RET_DROP for C++ template functions to suppress
11010 their return type. It is easier for GDB users to search
11011 for such functions as `name(params)' than `long name(params)'.
11012 In such case the minimal symbol names do not match the full
11013 symbol names but for template functions there is never a need
11014 to look up their definition from their declaration so
11015 the only disadvantage remains the minimal symbol variant
11016 `long name(params)' does not have the proper inferior type. */
11017 demangled.reset (gdb_demangle (mangled,
11018 (DMGL_PARAMS | DMGL_ANSI
11019 | DMGL_RET_DROP)));
11022 canon = demangled.get ();
11030 if (canon == NULL || check_physname)
11032 const char *physname = dwarf2_compute_name (name, die, cu, 1);
11034 if (canon != NULL && strcmp (physname, canon) != 0)
11036 /* It may not mean a bug in GDB. The compiler could also
11037 compute DW_AT_linkage_name incorrectly. But in such case
11038 GDB would need to be bug-to-bug compatible. */
11040 complaint (&symfile_complaints,
11041 _("Computed physname <%s> does not match demangled <%s> "
11042 "(from linkage <%s>) - DIE at %s [in module %s]"),
11043 physname, canon, mangled, sect_offset_str (die->sect_off),
11044 objfile_name (objfile));
11046 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11047 is available here - over computed PHYSNAME. It is safer
11048 against both buggy GDB and buggy compilers. */
11062 retval = ((const char *)
11063 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11064 retval, strlen (retval)));
11069 /* Inspect DIE in CU for a namespace alias. If one exists, record
11070 a new symbol for it.
11072 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11075 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11077 struct attribute *attr;
11079 /* If the die does not have a name, this is not a namespace
11081 attr = dwarf2_attr (die, DW_AT_name, cu);
11085 struct die_info *d = die;
11086 struct dwarf2_cu *imported_cu = cu;
11088 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11089 keep inspecting DIEs until we hit the underlying import. */
11090 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11091 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11093 attr = dwarf2_attr (d, DW_AT_import, cu);
11097 d = follow_die_ref (d, attr, &imported_cu);
11098 if (d->tag != DW_TAG_imported_declaration)
11102 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11104 complaint (&symfile_complaints,
11105 _("DIE at %s has too many recursively imported "
11106 "declarations"), sect_offset_str (d->sect_off));
11113 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11115 type = get_die_type_at_offset (sect_off, cu->per_cu);
11116 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11118 /* This declaration is a global namespace alias. Add
11119 a symbol for it whose type is the aliased namespace. */
11120 new_symbol (die, type, cu);
11129 /* Return the using directives repository (global or local?) to use in the
11130 current context for LANGUAGE.
11132 For Ada, imported declarations can materialize renamings, which *may* be
11133 global. However it is impossible (for now?) in DWARF to distinguish
11134 "external" imported declarations and "static" ones. As all imported
11135 declarations seem to be static in all other languages, make them all CU-wide
11136 global only in Ada. */
11138 static struct using_direct **
11139 using_directives (enum language language)
11141 if (language == language_ada && context_stack_depth == 0)
11142 return &global_using_directives;
11144 return &local_using_directives;
11147 /* Read the import statement specified by the given die and record it. */
11150 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11152 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11153 struct attribute *import_attr;
11154 struct die_info *imported_die, *child_die;
11155 struct dwarf2_cu *imported_cu;
11156 const char *imported_name;
11157 const char *imported_name_prefix;
11158 const char *canonical_name;
11159 const char *import_alias;
11160 const char *imported_declaration = NULL;
11161 const char *import_prefix;
11162 std::vector<const char *> excludes;
11164 import_attr = dwarf2_attr (die, DW_AT_import, cu);
11165 if (import_attr == NULL)
11167 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
11168 dwarf_tag_name (die->tag));
11173 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11174 imported_name = dwarf2_name (imported_die, imported_cu);
11175 if (imported_name == NULL)
11177 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11179 The import in the following code:
11193 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11194 <52> DW_AT_decl_file : 1
11195 <53> DW_AT_decl_line : 6
11196 <54> DW_AT_import : <0x75>
11197 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11198 <59> DW_AT_name : B
11199 <5b> DW_AT_decl_file : 1
11200 <5c> DW_AT_decl_line : 2
11201 <5d> DW_AT_type : <0x6e>
11203 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11204 <76> DW_AT_byte_size : 4
11205 <77> DW_AT_encoding : 5 (signed)
11207 imports the wrong die ( 0x75 instead of 0x58 ).
11208 This case will be ignored until the gcc bug is fixed. */
11212 /* Figure out the local name after import. */
11213 import_alias = dwarf2_name (die, cu);
11215 /* Figure out where the statement is being imported to. */
11216 import_prefix = determine_prefix (die, cu);
11218 /* Figure out what the scope of the imported die is and prepend it
11219 to the name of the imported die. */
11220 imported_name_prefix = determine_prefix (imported_die, imported_cu);
11222 if (imported_die->tag != DW_TAG_namespace
11223 && imported_die->tag != DW_TAG_module)
11225 imported_declaration = imported_name;
11226 canonical_name = imported_name_prefix;
11228 else if (strlen (imported_name_prefix) > 0)
11229 canonical_name = obconcat (&objfile->objfile_obstack,
11230 imported_name_prefix,
11231 (cu->language == language_d ? "." : "::"),
11232 imported_name, (char *) NULL);
11234 canonical_name = imported_name;
11236 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11237 for (child_die = die->child; child_die && child_die->tag;
11238 child_die = sibling_die (child_die))
11240 /* DWARF-4: A Fortran use statement with a “rename list” may be
11241 represented by an imported module entry with an import attribute
11242 referring to the module and owned entries corresponding to those
11243 entities that are renamed as part of being imported. */
11245 if (child_die->tag != DW_TAG_imported_declaration)
11247 complaint (&symfile_complaints,
11248 _("child DW_TAG_imported_declaration expected "
11249 "- DIE at %s [in module %s]"),
11250 sect_offset_str (child_die->sect_off),
11251 objfile_name (objfile));
11255 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11256 if (import_attr == NULL)
11258 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
11259 dwarf_tag_name (child_die->tag));
11264 imported_die = follow_die_ref_or_sig (child_die, import_attr,
11266 imported_name = dwarf2_name (imported_die, imported_cu);
11267 if (imported_name == NULL)
11269 complaint (&symfile_complaints,
11270 _("child DW_TAG_imported_declaration has unknown "
11271 "imported name - DIE at %s [in module %s]"),
11272 sect_offset_str (child_die->sect_off),
11273 objfile_name (objfile));
11277 excludes.push_back (imported_name);
11279 process_die (child_die, cu);
11282 add_using_directive (using_directives (cu->language),
11286 imported_declaration,
11289 &objfile->objfile_obstack);
11292 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11293 types, but gives them a size of zero. Starting with version 14,
11294 ICC is compatible with GCC. */
11297 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11299 if (!cu->checked_producer)
11300 check_producer (cu);
11302 return cu->producer_is_icc_lt_14;
11305 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11306 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11307 this, it was first present in GCC release 4.3.0. */
11310 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11312 if (!cu->checked_producer)
11313 check_producer (cu);
11315 return cu->producer_is_gcc_lt_4_3;
11318 static file_and_directory
11319 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11321 file_and_directory res;
11323 /* Find the filename. Do not use dwarf2_name here, since the filename
11324 is not a source language identifier. */
11325 res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11326 res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11328 if (res.comp_dir == NULL
11329 && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11330 && IS_ABSOLUTE_PATH (res.name))
11332 res.comp_dir_storage = ldirname (res.name);
11333 if (!res.comp_dir_storage.empty ())
11334 res.comp_dir = res.comp_dir_storage.c_str ();
11336 if (res.comp_dir != NULL)
11338 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11339 directory, get rid of it. */
11340 const char *cp = strchr (res.comp_dir, ':');
11342 if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11343 res.comp_dir = cp + 1;
11346 if (res.name == NULL)
11347 res.name = "<unknown>";
11352 /* Handle DW_AT_stmt_list for a compilation unit.
11353 DIE is the DW_TAG_compile_unit die for CU.
11354 COMP_DIR is the compilation directory. LOWPC is passed to
11355 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11358 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11359 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11361 struct dwarf2_per_objfile *dwarf2_per_objfile
11362 = cu->per_cu->dwarf2_per_objfile;
11363 struct objfile *objfile = dwarf2_per_objfile->objfile;
11364 struct attribute *attr;
11365 struct line_header line_header_local;
11366 hashval_t line_header_local_hash;
11368 int decode_mapping;
11370 gdb_assert (! cu->per_cu->is_debug_types);
11372 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11376 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11378 /* The line header hash table is only created if needed (it exists to
11379 prevent redundant reading of the line table for partial_units).
11380 If we're given a partial_unit, we'll need it. If we're given a
11381 compile_unit, then use the line header hash table if it's already
11382 created, but don't create one just yet. */
11384 if (dwarf2_per_objfile->line_header_hash == NULL
11385 && die->tag == DW_TAG_partial_unit)
11387 dwarf2_per_objfile->line_header_hash
11388 = htab_create_alloc_ex (127, line_header_hash_voidp,
11389 line_header_eq_voidp,
11390 free_line_header_voidp,
11391 &objfile->objfile_obstack,
11392 hashtab_obstack_allocate,
11393 dummy_obstack_deallocate);
11396 line_header_local.sect_off = line_offset;
11397 line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11398 line_header_local_hash = line_header_hash (&line_header_local);
11399 if (dwarf2_per_objfile->line_header_hash != NULL)
11401 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11402 &line_header_local,
11403 line_header_local_hash, NO_INSERT);
11405 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11406 is not present in *SLOT (since if there is something in *SLOT then
11407 it will be for a partial_unit). */
11408 if (die->tag == DW_TAG_partial_unit && slot != NULL)
11410 gdb_assert (*slot != NULL);
11411 cu->line_header = (struct line_header *) *slot;
11416 /* dwarf_decode_line_header does not yet provide sufficient information.
11417 We always have to call also dwarf_decode_lines for it. */
11418 line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11422 cu->line_header = lh.release ();
11423 cu->line_header_die_owner = die;
11425 if (dwarf2_per_objfile->line_header_hash == NULL)
11429 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11430 &line_header_local,
11431 line_header_local_hash, INSERT);
11432 gdb_assert (slot != NULL);
11434 if (slot != NULL && *slot == NULL)
11436 /* This newly decoded line number information unit will be owned
11437 by line_header_hash hash table. */
11438 *slot = cu->line_header;
11439 cu->line_header_die_owner = NULL;
11443 /* We cannot free any current entry in (*slot) as that struct line_header
11444 may be already used by multiple CUs. Create only temporary decoded
11445 line_header for this CU - it may happen at most once for each line
11446 number information unit. And if we're not using line_header_hash
11447 then this is what we want as well. */
11448 gdb_assert (die->tag != DW_TAG_partial_unit);
11450 decode_mapping = (die->tag != DW_TAG_partial_unit);
11451 dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11456 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11459 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11461 struct dwarf2_per_objfile *dwarf2_per_objfile
11462 = cu->per_cu->dwarf2_per_objfile;
11463 struct objfile *objfile = dwarf2_per_objfile->objfile;
11464 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11465 CORE_ADDR lowpc = ((CORE_ADDR) -1);
11466 CORE_ADDR highpc = ((CORE_ADDR) 0);
11467 struct attribute *attr;
11468 struct die_info *child_die;
11469 CORE_ADDR baseaddr;
11471 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11473 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11475 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11476 from finish_block. */
11477 if (lowpc == ((CORE_ADDR) -1))
11479 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11481 file_and_directory fnd = find_file_and_directory (die, cu);
11483 prepare_one_comp_unit (cu, die, cu->language);
11485 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11486 standardised yet. As a workaround for the language detection we fall
11487 back to the DW_AT_producer string. */
11488 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11489 cu->language = language_opencl;
11491 /* Similar hack for Go. */
11492 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11493 set_cu_language (DW_LANG_Go, cu);
11495 dwarf2_start_symtab (cu, fnd.name, fnd.comp_dir, lowpc);
11497 /* Decode line number information if present. We do this before
11498 processing child DIEs, so that the line header table is available
11499 for DW_AT_decl_file. */
11500 handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11502 /* Process all dies in compilation unit. */
11503 if (die->child != NULL)
11505 child_die = die->child;
11506 while (child_die && child_die->tag)
11508 process_die (child_die, cu);
11509 child_die = sibling_die (child_die);
11513 /* Decode macro information, if present. Dwarf 2 macro information
11514 refers to information in the line number info statement program
11515 header, so we can only read it if we've read the header
11517 attr = dwarf2_attr (die, DW_AT_macros, cu);
11519 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11520 if (attr && cu->line_header)
11522 if (dwarf2_attr (die, DW_AT_macro_info, cu))
11523 complaint (&symfile_complaints,
11524 _("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11526 dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11530 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11531 if (attr && cu->line_header)
11533 unsigned int macro_offset = DW_UNSND (attr);
11535 dwarf_decode_macros (cu, macro_offset, 0);
11540 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
11541 Create the set of symtabs used by this TU, or if this TU is sharing
11542 symtabs with another TU and the symtabs have already been created
11543 then restore those symtabs in the line header.
11544 We don't need the pc/line-number mapping for type units. */
11547 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
11549 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
11550 struct type_unit_group *tu_group;
11552 struct attribute *attr;
11554 struct signatured_type *sig_type;
11556 gdb_assert (per_cu->is_debug_types);
11557 sig_type = (struct signatured_type *) per_cu;
11559 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11561 /* If we're using .gdb_index (includes -readnow) then
11562 per_cu->type_unit_group may not have been set up yet. */
11563 if (sig_type->type_unit_group == NULL)
11564 sig_type->type_unit_group = get_type_unit_group (cu, attr);
11565 tu_group = sig_type->type_unit_group;
11567 /* If we've already processed this stmt_list there's no real need to
11568 do it again, we could fake it and just recreate the part we need
11569 (file name,index -> symtab mapping). If data shows this optimization
11570 is useful we can do it then. */
11571 first_time = tu_group->compunit_symtab == NULL;
11573 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11578 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11579 lh = dwarf_decode_line_header (line_offset, cu);
11584 dwarf2_start_symtab (cu, "", NULL, 0);
11587 gdb_assert (tu_group->symtabs == NULL);
11588 restart_symtab (tu_group->compunit_symtab, "", 0);
11593 cu->line_header = lh.release ();
11594 cu->line_header_die_owner = die;
11598 struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
11600 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11601 still initializing it, and our caller (a few levels up)
11602 process_full_type_unit still needs to know if this is the first
11605 tu_group->num_symtabs = cu->line_header->file_names.size ();
11606 tu_group->symtabs = XNEWVEC (struct symtab *,
11607 cu->line_header->file_names.size ());
11609 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11611 file_entry &fe = cu->line_header->file_names[i];
11613 dwarf2_start_subfile (fe.name, fe.include_dir (cu->line_header));
11615 if (current_subfile->symtab == NULL)
11617 /* NOTE: start_subfile will recognize when it's been
11618 passed a file it has already seen. So we can't
11619 assume there's a simple mapping from
11620 cu->line_header->file_names to subfiles, plus
11621 cu->line_header->file_names may contain dups. */
11622 current_subfile->symtab
11623 = allocate_symtab (cust, current_subfile->name);
11626 fe.symtab = current_subfile->symtab;
11627 tu_group->symtabs[i] = fe.symtab;
11632 restart_symtab (tu_group->compunit_symtab, "", 0);
11634 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11636 file_entry &fe = cu->line_header->file_names[i];
11638 fe.symtab = tu_group->symtabs[i];
11642 /* The main symtab is allocated last. Type units don't have DW_AT_name
11643 so they don't have a "real" (so to speak) symtab anyway.
11644 There is later code that will assign the main symtab to all symbols
11645 that don't have one. We need to handle the case of a symbol with a
11646 missing symtab (DW_AT_decl_file) anyway. */
11649 /* Process DW_TAG_type_unit.
11650 For TUs we want to skip the first top level sibling if it's not the
11651 actual type being defined by this TU. In this case the first top
11652 level sibling is there to provide context only. */
11655 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11657 struct die_info *child_die;
11659 prepare_one_comp_unit (cu, die, language_minimal);
11661 /* Initialize (or reinitialize) the machinery for building symtabs.
11662 We do this before processing child DIEs, so that the line header table
11663 is available for DW_AT_decl_file. */
11664 setup_type_unit_groups (die, cu);
11666 if (die->child != NULL)
11668 child_die = die->child;
11669 while (child_die && child_die->tag)
11671 process_die (child_die, cu);
11672 child_die = sibling_die (child_die);
11679 http://gcc.gnu.org/wiki/DebugFission
11680 http://gcc.gnu.org/wiki/DebugFissionDWP
11682 To simplify handling of both DWO files ("object" files with the DWARF info)
11683 and DWP files (a file with the DWOs packaged up into one file), we treat
11684 DWP files as having a collection of virtual DWO files. */
11687 hash_dwo_file (const void *item)
11689 const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11692 hash = htab_hash_string (dwo_file->dwo_name);
11693 if (dwo_file->comp_dir != NULL)
11694 hash += htab_hash_string (dwo_file->comp_dir);
11699 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11701 const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11702 const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11704 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11706 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11707 return lhs->comp_dir == rhs->comp_dir;
11708 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11711 /* Allocate a hash table for DWO files. */
11714 allocate_dwo_file_hash_table (struct objfile *objfile)
11716 return htab_create_alloc_ex (41,
11720 &objfile->objfile_obstack,
11721 hashtab_obstack_allocate,
11722 dummy_obstack_deallocate);
11725 /* Lookup DWO file DWO_NAME. */
11728 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11729 const char *dwo_name,
11730 const char *comp_dir)
11732 struct dwo_file find_entry;
11735 if (dwarf2_per_objfile->dwo_files == NULL)
11736 dwarf2_per_objfile->dwo_files
11737 = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11739 memset (&find_entry, 0, sizeof (find_entry));
11740 find_entry.dwo_name = dwo_name;
11741 find_entry.comp_dir = comp_dir;
11742 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11748 hash_dwo_unit (const void *item)
11750 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11752 /* This drops the top 32 bits of the id, but is ok for a hash. */
11753 return dwo_unit->signature;
11757 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11759 const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11760 const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11762 /* The signature is assumed to be unique within the DWO file.
11763 So while object file CU dwo_id's always have the value zero,
11764 that's OK, assuming each object file DWO file has only one CU,
11765 and that's the rule for now. */
11766 return lhs->signature == rhs->signature;
11769 /* Allocate a hash table for DWO CUs,TUs.
11770 There is one of these tables for each of CUs,TUs for each DWO file. */
11773 allocate_dwo_unit_table (struct objfile *objfile)
11775 /* Start out with a pretty small number.
11776 Generally DWO files contain only one CU and maybe some TUs. */
11777 return htab_create_alloc_ex (3,
11781 &objfile->objfile_obstack,
11782 hashtab_obstack_allocate,
11783 dummy_obstack_deallocate);
11786 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11788 struct create_dwo_cu_data
11790 struct dwo_file *dwo_file;
11791 struct dwo_unit dwo_unit;
11794 /* die_reader_func for create_dwo_cu. */
11797 create_dwo_cu_reader (const struct die_reader_specs *reader,
11798 const gdb_byte *info_ptr,
11799 struct die_info *comp_unit_die,
11803 struct dwarf2_cu *cu = reader->cu;
11804 sect_offset sect_off = cu->per_cu->sect_off;
11805 struct dwarf2_section_info *section = cu->per_cu->section;
11806 struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11807 struct dwo_file *dwo_file = data->dwo_file;
11808 struct dwo_unit *dwo_unit = &data->dwo_unit;
11809 struct attribute *attr;
11811 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11814 complaint (&symfile_complaints,
11815 _("Dwarf Error: debug entry at offset %s is missing"
11816 " its dwo_id [in module %s]"),
11817 sect_offset_str (sect_off), dwo_file->dwo_name);
11821 dwo_unit->dwo_file = dwo_file;
11822 dwo_unit->signature = DW_UNSND (attr);
11823 dwo_unit->section = section;
11824 dwo_unit->sect_off = sect_off;
11825 dwo_unit->length = cu->per_cu->length;
11827 if (dwarf_read_debug)
11828 fprintf_unfiltered (gdb_stdlog, " offset %s, dwo_id %s\n",
11829 sect_offset_str (sect_off),
11830 hex_string (dwo_unit->signature));
11833 /* Create the dwo_units for the CUs in a DWO_FILE.
11834 Note: This function processes DWO files only, not DWP files. */
11837 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11838 struct dwo_file &dwo_file, dwarf2_section_info §ion,
11841 struct objfile *objfile = dwarf2_per_objfile->objfile;
11842 const gdb_byte *info_ptr, *end_ptr;
11844 dwarf2_read_section (objfile, §ion);
11845 info_ptr = section.buffer;
11847 if (info_ptr == NULL)
11850 if (dwarf_read_debug)
11852 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11853 get_section_name (§ion),
11854 get_section_file_name (§ion));
11857 end_ptr = info_ptr + section.size;
11858 while (info_ptr < end_ptr)
11860 struct dwarf2_per_cu_data per_cu;
11861 struct create_dwo_cu_data create_dwo_cu_data;
11862 struct dwo_unit *dwo_unit;
11864 sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11866 memset (&create_dwo_cu_data.dwo_unit, 0,
11867 sizeof (create_dwo_cu_data.dwo_unit));
11868 memset (&per_cu, 0, sizeof (per_cu));
11869 per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11870 per_cu.is_debug_types = 0;
11871 per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11872 per_cu.section = §ion;
11873 create_dwo_cu_data.dwo_file = &dwo_file;
11875 init_cutu_and_read_dies_no_follow (
11876 &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11877 info_ptr += per_cu.length;
11879 // If the unit could not be parsed, skip it.
11880 if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11883 if (cus_htab == NULL)
11884 cus_htab = allocate_dwo_unit_table (objfile);
11886 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11887 *dwo_unit = create_dwo_cu_data.dwo_unit;
11888 slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11889 gdb_assert (slot != NULL);
11892 const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11893 sect_offset dup_sect_off = dup_cu->sect_off;
11895 complaint (&symfile_complaints,
11896 _("debug cu entry at offset %s is duplicate to"
11897 " the entry at offset %s, signature %s"),
11898 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11899 hex_string (dwo_unit->signature));
11901 *slot = (void *)dwo_unit;
11905 /* DWP file .debug_{cu,tu}_index section format:
11906 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11910 Both index sections have the same format, and serve to map a 64-bit
11911 signature to a set of section numbers. Each section begins with a header,
11912 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11913 indexes, and a pool of 32-bit section numbers. The index sections will be
11914 aligned at 8-byte boundaries in the file.
11916 The index section header consists of:
11918 V, 32 bit version number
11920 N, 32 bit number of compilation units or type units in the index
11921 M, 32 bit number of slots in the hash table
11923 Numbers are recorded using the byte order of the application binary.
11925 The hash table begins at offset 16 in the section, and consists of an array
11926 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11927 order of the application binary). Unused slots in the hash table are 0.
11928 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11930 The parallel table begins immediately after the hash table
11931 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11932 array of 32-bit indexes (using the byte order of the application binary),
11933 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11934 table contains a 32-bit index into the pool of section numbers. For unused
11935 hash table slots, the corresponding entry in the parallel table will be 0.
11937 The pool of section numbers begins immediately following the hash table
11938 (at offset 16 + 12 * M from the beginning of the section). The pool of
11939 section numbers consists of an array of 32-bit words (using the byte order
11940 of the application binary). Each item in the array is indexed starting
11941 from 0. The hash table entry provides the index of the first section
11942 number in the set. Additional section numbers in the set follow, and the
11943 set is terminated by a 0 entry (section number 0 is not used in ELF).
11945 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11946 section must be the first entry in the set, and the .debug_abbrev.dwo must
11947 be the second entry. Other members of the set may follow in any order.
11953 DWP Version 2 combines all the .debug_info, etc. sections into one,
11954 and the entries in the index tables are now offsets into these sections.
11955 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11958 Index Section Contents:
11960 Hash Table of Signatures dwp_hash_table.hash_table
11961 Parallel Table of Indices dwp_hash_table.unit_table
11962 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
11963 Table of Section Sizes dwp_hash_table.v2.sizes
11965 The index section header consists of:
11967 V, 32 bit version number
11968 L, 32 bit number of columns in the table of section offsets
11969 N, 32 bit number of compilation units or type units in the index
11970 M, 32 bit number of slots in the hash table
11972 Numbers are recorded using the byte order of the application binary.
11974 The hash table has the same format as version 1.
11975 The parallel table of indices has the same format as version 1,
11976 except that the entries are origin-1 indices into the table of sections
11977 offsets and the table of section sizes.
11979 The table of offsets begins immediately following the parallel table
11980 (at offset 16 + 12 * M from the beginning of the section). The table is
11981 a two-dimensional array of 32-bit words (using the byte order of the
11982 application binary), with L columns and N+1 rows, in row-major order.
11983 Each row in the array is indexed starting from 0. The first row provides
11984 a key to the remaining rows: each column in this row provides an identifier
11985 for a debug section, and the offsets in the same column of subsequent rows
11986 refer to that section. The section identifiers are:
11988 DW_SECT_INFO 1 .debug_info.dwo
11989 DW_SECT_TYPES 2 .debug_types.dwo
11990 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11991 DW_SECT_LINE 4 .debug_line.dwo
11992 DW_SECT_LOC 5 .debug_loc.dwo
11993 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11994 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11995 DW_SECT_MACRO 8 .debug_macro.dwo
11997 The offsets provided by the CU and TU index sections are the base offsets
11998 for the contributions made by each CU or TU to the corresponding section
11999 in the package file. Each CU and TU header contains an abbrev_offset
12000 field, used to find the abbreviations table for that CU or TU within the
12001 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12002 be interpreted as relative to the base offset given in the index section.
12003 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12004 should be interpreted as relative to the base offset for .debug_line.dwo,
12005 and offsets into other debug sections obtained from DWARF attributes should
12006 also be interpreted as relative to the corresponding base offset.
12008 The table of sizes begins immediately following the table of offsets.
12009 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12010 with L columns and N rows, in row-major order. Each row in the array is
12011 indexed starting from 1 (row 0 is shared by the two tables).
12015 Hash table lookup is handled the same in version 1 and 2:
12017 We assume that N and M will not exceed 2^32 - 1.
12018 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12020 Given a 64-bit compilation unit signature or a type signature S, an entry
12021 in the hash table is located as follows:
12023 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12024 the low-order k bits all set to 1.
12026 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12028 3) If the hash table entry at index H matches the signature, use that
12029 entry. If the hash table entry at index H is unused (all zeroes),
12030 terminate the search: the signature is not present in the table.
12032 4) Let H = (H + H') modulo M. Repeat at Step 3.
12034 Because M > N and H' and M are relatively prime, the search is guaranteed
12035 to stop at an unused slot or find the match. */
12037 /* Create a hash table to map DWO IDs to their CU/TU entry in
12038 .debug_{info,types}.dwo in DWP_FILE.
12039 Returns NULL if there isn't one.
12040 Note: This function processes DWP files only, not DWO files. */
12042 static struct dwp_hash_table *
12043 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12044 struct dwp_file *dwp_file, int is_debug_types)
12046 struct objfile *objfile = dwarf2_per_objfile->objfile;
12047 bfd *dbfd = dwp_file->dbfd.get ();
12048 const gdb_byte *index_ptr, *index_end;
12049 struct dwarf2_section_info *index;
12050 uint32_t version, nr_columns, nr_units, nr_slots;
12051 struct dwp_hash_table *htab;
12053 if (is_debug_types)
12054 index = &dwp_file->sections.tu_index;
12056 index = &dwp_file->sections.cu_index;
12058 if (dwarf2_section_empty_p (index))
12060 dwarf2_read_section (objfile, index);
12062 index_ptr = index->buffer;
12063 index_end = index_ptr + index->size;
12065 version = read_4_bytes (dbfd, index_ptr);
12068 nr_columns = read_4_bytes (dbfd, index_ptr);
12072 nr_units = read_4_bytes (dbfd, index_ptr);
12074 nr_slots = read_4_bytes (dbfd, index_ptr);
12077 if (version != 1 && version != 2)
12079 error (_("Dwarf Error: unsupported DWP file version (%s)"
12080 " [in module %s]"),
12081 pulongest (version), dwp_file->name);
12083 if (nr_slots != (nr_slots & -nr_slots))
12085 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12086 " is not power of 2 [in module %s]"),
12087 pulongest (nr_slots), dwp_file->name);
12090 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12091 htab->version = version;
12092 htab->nr_columns = nr_columns;
12093 htab->nr_units = nr_units;
12094 htab->nr_slots = nr_slots;
12095 htab->hash_table = index_ptr;
12096 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12098 /* Exit early if the table is empty. */
12099 if (nr_slots == 0 || nr_units == 0
12100 || (version == 2 && nr_columns == 0))
12102 /* All must be zero. */
12103 if (nr_slots != 0 || nr_units != 0
12104 || (version == 2 && nr_columns != 0))
12106 complaint (&symfile_complaints,
12107 _("Empty DWP but nr_slots,nr_units,nr_columns not"
12108 " all zero [in modules %s]"),
12116 htab->section_pool.v1.indices =
12117 htab->unit_table + sizeof (uint32_t) * nr_slots;
12118 /* It's harder to decide whether the section is too small in v1.
12119 V1 is deprecated anyway so we punt. */
12123 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12124 int *ids = htab->section_pool.v2.section_ids;
12125 /* Reverse map for error checking. */
12126 int ids_seen[DW_SECT_MAX + 1];
12129 if (nr_columns < 2)
12131 error (_("Dwarf Error: bad DWP hash table, too few columns"
12132 " in section table [in module %s]"),
12135 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12137 error (_("Dwarf Error: bad DWP hash table, too many columns"
12138 " in section table [in module %s]"),
12141 memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
12142 memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
12143 for (i = 0; i < nr_columns; ++i)
12145 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12147 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12149 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12150 " in section table [in module %s]"),
12151 id, dwp_file->name);
12153 if (ids_seen[id] != -1)
12155 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12156 " id %d in section table [in module %s]"),
12157 id, dwp_file->name);
12162 /* Must have exactly one info or types section. */
12163 if (((ids_seen[DW_SECT_INFO] != -1)
12164 + (ids_seen[DW_SECT_TYPES] != -1))
12167 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12168 " DWO info/types section [in module %s]"),
12171 /* Must have an abbrev section. */
12172 if (ids_seen[DW_SECT_ABBREV] == -1)
12174 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12175 " section [in module %s]"),
12178 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12179 htab->section_pool.v2.sizes =
12180 htab->section_pool.v2.offsets + (sizeof (uint32_t)
12181 * nr_units * nr_columns);
12182 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12183 * nr_units * nr_columns))
12186 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12187 " [in module %s]"),
12195 /* Update SECTIONS with the data from SECTP.
12197 This function is like the other "locate" section routines that are
12198 passed to bfd_map_over_sections, but in this context the sections to
12199 read comes from the DWP V1 hash table, not the full ELF section table.
12201 The result is non-zero for success, or zero if an error was found. */
12204 locate_v1_virtual_dwo_sections (asection *sectp,
12205 struct virtual_v1_dwo_sections *sections)
12207 const struct dwop_section_names *names = &dwop_section_names;
12209 if (section_is_p (sectp->name, &names->abbrev_dwo))
12211 /* There can be only one. */
12212 if (sections->abbrev.s.section != NULL)
12214 sections->abbrev.s.section = sectp;
12215 sections->abbrev.size = bfd_get_section_size (sectp);
12217 else if (section_is_p (sectp->name, &names->info_dwo)
12218 || section_is_p (sectp->name, &names->types_dwo))
12220 /* There can be only one. */
12221 if (sections->info_or_types.s.section != NULL)
12223 sections->info_or_types.s.section = sectp;
12224 sections->info_or_types.size = bfd_get_section_size (sectp);
12226 else if (section_is_p (sectp->name, &names->line_dwo))
12228 /* There can be only one. */
12229 if (sections->line.s.section != NULL)
12231 sections->line.s.section = sectp;
12232 sections->line.size = bfd_get_section_size (sectp);
12234 else if (section_is_p (sectp->name, &names->loc_dwo))
12236 /* There can be only one. */
12237 if (sections->loc.s.section != NULL)
12239 sections->loc.s.section = sectp;
12240 sections->loc.size = bfd_get_section_size (sectp);
12242 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12244 /* There can be only one. */
12245 if (sections->macinfo.s.section != NULL)
12247 sections->macinfo.s.section = sectp;
12248 sections->macinfo.size = bfd_get_section_size (sectp);
12250 else if (section_is_p (sectp->name, &names->macro_dwo))
12252 /* There can be only one. */
12253 if (sections->macro.s.section != NULL)
12255 sections->macro.s.section = sectp;
12256 sections->macro.size = bfd_get_section_size (sectp);
12258 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12260 /* There can be only one. */
12261 if (sections->str_offsets.s.section != NULL)
12263 sections->str_offsets.s.section = sectp;
12264 sections->str_offsets.size = bfd_get_section_size (sectp);
12268 /* No other kind of section is valid. */
12275 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12276 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12277 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12278 This is for DWP version 1 files. */
12280 static struct dwo_unit *
12281 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12282 struct dwp_file *dwp_file,
12283 uint32_t unit_index,
12284 const char *comp_dir,
12285 ULONGEST signature, int is_debug_types)
12287 struct objfile *objfile = dwarf2_per_objfile->objfile;
12288 const struct dwp_hash_table *dwp_htab =
12289 is_debug_types ? dwp_file->tus : dwp_file->cus;
12290 bfd *dbfd = dwp_file->dbfd.get ();
12291 const char *kind = is_debug_types ? "TU" : "CU";
12292 struct dwo_file *dwo_file;
12293 struct dwo_unit *dwo_unit;
12294 struct virtual_v1_dwo_sections sections;
12295 void **dwo_file_slot;
12298 gdb_assert (dwp_file->version == 1);
12300 if (dwarf_read_debug)
12302 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12304 pulongest (unit_index), hex_string (signature),
12308 /* Fetch the sections of this DWO unit.
12309 Put a limit on the number of sections we look for so that bad data
12310 doesn't cause us to loop forever. */
12312 #define MAX_NR_V1_DWO_SECTIONS \
12313 (1 /* .debug_info or .debug_types */ \
12314 + 1 /* .debug_abbrev */ \
12315 + 1 /* .debug_line */ \
12316 + 1 /* .debug_loc */ \
12317 + 1 /* .debug_str_offsets */ \
12318 + 1 /* .debug_macro or .debug_macinfo */ \
12319 + 1 /* trailing zero */)
12321 memset (§ions, 0, sizeof (sections));
12323 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12326 uint32_t section_nr =
12327 read_4_bytes (dbfd,
12328 dwp_htab->section_pool.v1.indices
12329 + (unit_index + i) * sizeof (uint32_t));
12331 if (section_nr == 0)
12333 if (section_nr >= dwp_file->num_sections)
12335 error (_("Dwarf Error: bad DWP hash table, section number too large"
12336 " [in module %s]"),
12340 sectp = dwp_file->elf_sections[section_nr];
12341 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
12343 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12344 " [in module %s]"),
12350 || dwarf2_section_empty_p (§ions.info_or_types)
12351 || dwarf2_section_empty_p (§ions.abbrev))
12353 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12354 " [in module %s]"),
12357 if (i == MAX_NR_V1_DWO_SECTIONS)
12359 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12360 " [in module %s]"),
12364 /* It's easier for the rest of the code if we fake a struct dwo_file and
12365 have dwo_unit "live" in that. At least for now.
12367 The DWP file can be made up of a random collection of CUs and TUs.
12368 However, for each CU + set of TUs that came from the same original DWO
12369 file, we can combine them back into a virtual DWO file to save space
12370 (fewer struct dwo_file objects to allocate). Remember that for really
12371 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12373 std::string virtual_dwo_name =
12374 string_printf ("virtual-dwo/%d-%d-%d-%d",
12375 get_section_id (§ions.abbrev),
12376 get_section_id (§ions.line),
12377 get_section_id (§ions.loc),
12378 get_section_id (§ions.str_offsets));
12379 /* Can we use an existing virtual DWO file? */
12380 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12381 virtual_dwo_name.c_str (),
12383 /* Create one if necessary. */
12384 if (*dwo_file_slot == NULL)
12386 if (dwarf_read_debug)
12388 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12389 virtual_dwo_name.c_str ());
12391 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12393 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12394 virtual_dwo_name.c_str (),
12395 virtual_dwo_name.size ());
12396 dwo_file->comp_dir = comp_dir;
12397 dwo_file->sections.abbrev = sections.abbrev;
12398 dwo_file->sections.line = sections.line;
12399 dwo_file->sections.loc = sections.loc;
12400 dwo_file->sections.macinfo = sections.macinfo;
12401 dwo_file->sections.macro = sections.macro;
12402 dwo_file->sections.str_offsets = sections.str_offsets;
12403 /* The "str" section is global to the entire DWP file. */
12404 dwo_file->sections.str = dwp_file->sections.str;
12405 /* The info or types section is assigned below to dwo_unit,
12406 there's no need to record it in dwo_file.
12407 Also, we can't simply record type sections in dwo_file because
12408 we record a pointer into the vector in dwo_unit. As we collect more
12409 types we'll grow the vector and eventually have to reallocate space
12410 for it, invalidating all copies of pointers into the previous
12412 *dwo_file_slot = dwo_file;
12416 if (dwarf_read_debug)
12418 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12419 virtual_dwo_name.c_str ());
12421 dwo_file = (struct dwo_file *) *dwo_file_slot;
12424 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12425 dwo_unit->dwo_file = dwo_file;
12426 dwo_unit->signature = signature;
12427 dwo_unit->section =
12428 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12429 *dwo_unit->section = sections.info_or_types;
12430 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12435 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12436 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12437 piece within that section used by a TU/CU, return a virtual section
12438 of just that piece. */
12440 static struct dwarf2_section_info
12441 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12442 struct dwarf2_section_info *section,
12443 bfd_size_type offset, bfd_size_type size)
12445 struct dwarf2_section_info result;
12448 gdb_assert (section != NULL);
12449 gdb_assert (!section->is_virtual);
12451 memset (&result, 0, sizeof (result));
12452 result.s.containing_section = section;
12453 result.is_virtual = 1;
12458 sectp = get_section_bfd_section (section);
12460 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12461 bounds of the real section. This is a pretty-rare event, so just
12462 flag an error (easier) instead of a warning and trying to cope. */
12464 || offset + size > bfd_get_section_size (sectp))
12466 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12467 " in section %s [in module %s]"),
12468 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12469 objfile_name (dwarf2_per_objfile->objfile));
12472 result.virtual_offset = offset;
12473 result.size = size;
12477 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12478 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12479 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12480 This is for DWP version 2 files. */
12482 static struct dwo_unit *
12483 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12484 struct dwp_file *dwp_file,
12485 uint32_t unit_index,
12486 const char *comp_dir,
12487 ULONGEST signature, int is_debug_types)
12489 struct objfile *objfile = dwarf2_per_objfile->objfile;
12490 const struct dwp_hash_table *dwp_htab =
12491 is_debug_types ? dwp_file->tus : dwp_file->cus;
12492 bfd *dbfd = dwp_file->dbfd.get ();
12493 const char *kind = is_debug_types ? "TU" : "CU";
12494 struct dwo_file *dwo_file;
12495 struct dwo_unit *dwo_unit;
12496 struct virtual_v2_dwo_sections sections;
12497 void **dwo_file_slot;
12500 gdb_assert (dwp_file->version == 2);
12502 if (dwarf_read_debug)
12504 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12506 pulongest (unit_index), hex_string (signature),
12510 /* Fetch the section offsets of this DWO unit. */
12512 memset (§ions, 0, sizeof (sections));
12514 for (i = 0; i < dwp_htab->nr_columns; ++i)
12516 uint32_t offset = read_4_bytes (dbfd,
12517 dwp_htab->section_pool.v2.offsets
12518 + (((unit_index - 1) * dwp_htab->nr_columns
12520 * sizeof (uint32_t)));
12521 uint32_t size = read_4_bytes (dbfd,
12522 dwp_htab->section_pool.v2.sizes
12523 + (((unit_index - 1) * dwp_htab->nr_columns
12525 * sizeof (uint32_t)));
12527 switch (dwp_htab->section_pool.v2.section_ids[i])
12530 case DW_SECT_TYPES:
12531 sections.info_or_types_offset = offset;
12532 sections.info_or_types_size = size;
12534 case DW_SECT_ABBREV:
12535 sections.abbrev_offset = offset;
12536 sections.abbrev_size = size;
12539 sections.line_offset = offset;
12540 sections.line_size = size;
12543 sections.loc_offset = offset;
12544 sections.loc_size = size;
12546 case DW_SECT_STR_OFFSETS:
12547 sections.str_offsets_offset = offset;
12548 sections.str_offsets_size = size;
12550 case DW_SECT_MACINFO:
12551 sections.macinfo_offset = offset;
12552 sections.macinfo_size = size;
12554 case DW_SECT_MACRO:
12555 sections.macro_offset = offset;
12556 sections.macro_size = size;
12561 /* It's easier for the rest of the code if we fake a struct dwo_file and
12562 have dwo_unit "live" in that. At least for now.
12564 The DWP file can be made up of a random collection of CUs and TUs.
12565 However, for each CU + set of TUs that came from the same original DWO
12566 file, we can combine them back into a virtual DWO file to save space
12567 (fewer struct dwo_file objects to allocate). Remember that for really
12568 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12570 std::string virtual_dwo_name =
12571 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12572 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12573 (long) (sections.line_size ? sections.line_offset : 0),
12574 (long) (sections.loc_size ? sections.loc_offset : 0),
12575 (long) (sections.str_offsets_size
12576 ? sections.str_offsets_offset : 0));
12577 /* Can we use an existing virtual DWO file? */
12578 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12579 virtual_dwo_name.c_str (),
12581 /* Create one if necessary. */
12582 if (*dwo_file_slot == NULL)
12584 if (dwarf_read_debug)
12586 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12587 virtual_dwo_name.c_str ());
12589 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12591 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12592 virtual_dwo_name.c_str (),
12593 virtual_dwo_name.size ());
12594 dwo_file->comp_dir = comp_dir;
12595 dwo_file->sections.abbrev =
12596 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12597 sections.abbrev_offset, sections.abbrev_size);
12598 dwo_file->sections.line =
12599 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12600 sections.line_offset, sections.line_size);
12601 dwo_file->sections.loc =
12602 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12603 sections.loc_offset, sections.loc_size);
12604 dwo_file->sections.macinfo =
12605 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12606 sections.macinfo_offset, sections.macinfo_size);
12607 dwo_file->sections.macro =
12608 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12609 sections.macro_offset, sections.macro_size);
12610 dwo_file->sections.str_offsets =
12611 create_dwp_v2_section (dwarf2_per_objfile,
12612 &dwp_file->sections.str_offsets,
12613 sections.str_offsets_offset,
12614 sections.str_offsets_size);
12615 /* The "str" section is global to the entire DWP file. */
12616 dwo_file->sections.str = dwp_file->sections.str;
12617 /* The info or types section is assigned below to dwo_unit,
12618 there's no need to record it in dwo_file.
12619 Also, we can't simply record type sections in dwo_file because
12620 we record a pointer into the vector in dwo_unit. As we collect more
12621 types we'll grow the vector and eventually have to reallocate space
12622 for it, invalidating all copies of pointers into the previous
12624 *dwo_file_slot = dwo_file;
12628 if (dwarf_read_debug)
12630 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12631 virtual_dwo_name.c_str ());
12633 dwo_file = (struct dwo_file *) *dwo_file_slot;
12636 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12637 dwo_unit->dwo_file = dwo_file;
12638 dwo_unit->signature = signature;
12639 dwo_unit->section =
12640 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12641 *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12643 ? &dwp_file->sections.types
12644 : &dwp_file->sections.info,
12645 sections.info_or_types_offset,
12646 sections.info_or_types_size);
12647 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12652 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12653 Returns NULL if the signature isn't found. */
12655 static struct dwo_unit *
12656 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12657 struct dwp_file *dwp_file, const char *comp_dir,
12658 ULONGEST signature, int is_debug_types)
12660 const struct dwp_hash_table *dwp_htab =
12661 is_debug_types ? dwp_file->tus : dwp_file->cus;
12662 bfd *dbfd = dwp_file->dbfd.get ();
12663 uint32_t mask = dwp_htab->nr_slots - 1;
12664 uint32_t hash = signature & mask;
12665 uint32_t hash2 = ((signature >> 32) & mask) | 1;
12668 struct dwo_unit find_dwo_cu;
12670 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12671 find_dwo_cu.signature = signature;
12672 slot = htab_find_slot (is_debug_types
12673 ? dwp_file->loaded_tus
12674 : dwp_file->loaded_cus,
12675 &find_dwo_cu, INSERT);
12678 return (struct dwo_unit *) *slot;
12680 /* Use a for loop so that we don't loop forever on bad debug info. */
12681 for (i = 0; i < dwp_htab->nr_slots; ++i)
12683 ULONGEST signature_in_table;
12685 signature_in_table =
12686 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12687 if (signature_in_table == signature)
12689 uint32_t unit_index =
12690 read_4_bytes (dbfd,
12691 dwp_htab->unit_table + hash * sizeof (uint32_t));
12693 if (dwp_file->version == 1)
12695 *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12696 dwp_file, unit_index,
12697 comp_dir, signature,
12702 *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12703 dwp_file, unit_index,
12704 comp_dir, signature,
12707 return (struct dwo_unit *) *slot;
12709 if (signature_in_table == 0)
12711 hash = (hash + hash2) & mask;
12714 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12715 " [in module %s]"),
12719 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12720 Open the file specified by FILE_NAME and hand it off to BFD for
12721 preliminary analysis. Return a newly initialized bfd *, which
12722 includes a canonicalized copy of FILE_NAME.
12723 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12724 SEARCH_CWD is true if the current directory is to be searched.
12725 It will be searched before debug-file-directory.
12726 If successful, the file is added to the bfd include table of the
12727 objfile's bfd (see gdb_bfd_record_inclusion).
12728 If unable to find/open the file, return NULL.
12729 NOTE: This function is derived from symfile_bfd_open. */
12731 static gdb_bfd_ref_ptr
12732 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12733 const char *file_name, int is_dwp, int search_cwd)
12736 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12737 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12738 to debug_file_directory. */
12739 const char *search_path;
12740 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12742 gdb::unique_xmalloc_ptr<char> search_path_holder;
12745 if (*debug_file_directory != '\0')
12747 search_path_holder.reset (concat (".", dirname_separator_string,
12748 debug_file_directory,
12750 search_path = search_path_holder.get ();
12756 search_path = debug_file_directory;
12758 openp_flags flags = OPF_RETURN_REALPATH;
12760 flags |= OPF_SEARCH_IN_PATH;
12762 gdb::unique_xmalloc_ptr<char> absolute_name;
12763 desc = openp (search_path, flags, file_name,
12764 O_RDONLY | O_BINARY, &absolute_name);
12768 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12770 if (sym_bfd == NULL)
12772 bfd_set_cacheable (sym_bfd.get (), 1);
12774 if (!bfd_check_format (sym_bfd.get (), bfd_object))
12777 /* Success. Record the bfd as having been included by the objfile's bfd.
12778 This is important because things like demangled_names_hash lives in the
12779 objfile's per_bfd space and may have references to things like symbol
12780 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12781 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12786 /* Try to open DWO file FILE_NAME.
12787 COMP_DIR is the DW_AT_comp_dir attribute.
12788 The result is the bfd handle of the file.
12789 If there is a problem finding or opening the file, return NULL.
12790 Upon success, the canonicalized path of the file is stored in the bfd,
12791 same as symfile_bfd_open. */
12793 static gdb_bfd_ref_ptr
12794 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12795 const char *file_name, const char *comp_dir)
12797 if (IS_ABSOLUTE_PATH (file_name))
12798 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12799 0 /*is_dwp*/, 0 /*search_cwd*/);
12801 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12803 if (comp_dir != NULL)
12805 char *path_to_try = concat (comp_dir, SLASH_STRING,
12806 file_name, (char *) NULL);
12808 /* NOTE: If comp_dir is a relative path, this will also try the
12809 search path, which seems useful. */
12810 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12813 1 /*search_cwd*/));
12814 xfree (path_to_try);
12819 /* That didn't work, try debug-file-directory, which, despite its name,
12820 is a list of paths. */
12822 if (*debug_file_directory == '\0')
12825 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12826 0 /*is_dwp*/, 1 /*search_cwd*/);
12829 /* This function is mapped across the sections and remembers the offset and
12830 size of each of the DWO debugging sections we are interested in. */
12833 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12835 struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12836 const struct dwop_section_names *names = &dwop_section_names;
12838 if (section_is_p (sectp->name, &names->abbrev_dwo))
12840 dwo_sections->abbrev.s.section = sectp;
12841 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12843 else if (section_is_p (sectp->name, &names->info_dwo))
12845 dwo_sections->info.s.section = sectp;
12846 dwo_sections->info.size = bfd_get_section_size (sectp);
12848 else if (section_is_p (sectp->name, &names->line_dwo))
12850 dwo_sections->line.s.section = sectp;
12851 dwo_sections->line.size = bfd_get_section_size (sectp);
12853 else if (section_is_p (sectp->name, &names->loc_dwo))
12855 dwo_sections->loc.s.section = sectp;
12856 dwo_sections->loc.size = bfd_get_section_size (sectp);
12858 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12860 dwo_sections->macinfo.s.section = sectp;
12861 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12863 else if (section_is_p (sectp->name, &names->macro_dwo))
12865 dwo_sections->macro.s.section = sectp;
12866 dwo_sections->macro.size = bfd_get_section_size (sectp);
12868 else if (section_is_p (sectp->name, &names->str_dwo))
12870 dwo_sections->str.s.section = sectp;
12871 dwo_sections->str.size = bfd_get_section_size (sectp);
12873 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12875 dwo_sections->str_offsets.s.section = sectp;
12876 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12878 else if (section_is_p (sectp->name, &names->types_dwo))
12880 struct dwarf2_section_info type_section;
12882 memset (&type_section, 0, sizeof (type_section));
12883 type_section.s.section = sectp;
12884 type_section.size = bfd_get_section_size (sectp);
12885 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12890 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12891 by PER_CU. This is for the non-DWP case.
12892 The result is NULL if DWO_NAME can't be found. */
12894 static struct dwo_file *
12895 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12896 const char *dwo_name, const char *comp_dir)
12898 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12899 struct objfile *objfile = dwarf2_per_objfile->objfile;
12901 gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12904 if (dwarf_read_debug)
12905 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12909 /* We use a unique pointer here, despite the obstack allocation,
12910 because a dwo_file needs some cleanup if it is abandoned. */
12911 dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
12913 dwo_file->dwo_name = dwo_name;
12914 dwo_file->comp_dir = comp_dir;
12915 dwo_file->dbfd = dbfd.release ();
12917 bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
12918 &dwo_file->sections);
12920 create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
12923 create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
12924 dwo_file->sections.types, dwo_file->tus);
12926 if (dwarf_read_debug)
12927 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
12929 return dwo_file.release ();
12932 /* This function is mapped across the sections and remembers the offset and
12933 size of each of the DWP debugging sections common to version 1 and 2 that
12934 we are interested in. */
12937 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
12938 void *dwp_file_ptr)
12940 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
12941 const struct dwop_section_names *names = &dwop_section_names;
12942 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
12944 /* Record the ELF section number for later lookup: this is what the
12945 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12946 gdb_assert (elf_section_nr < dwp_file->num_sections);
12947 dwp_file->elf_sections[elf_section_nr] = sectp;
12949 /* Look for specific sections that we need. */
12950 if (section_is_p (sectp->name, &names->str_dwo))
12952 dwp_file->sections.str.s.section = sectp;
12953 dwp_file->sections.str.size = bfd_get_section_size (sectp);
12955 else if (section_is_p (sectp->name, &names->cu_index))
12957 dwp_file->sections.cu_index.s.section = sectp;
12958 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
12960 else if (section_is_p (sectp->name, &names->tu_index))
12962 dwp_file->sections.tu_index.s.section = sectp;
12963 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
12967 /* This function is mapped across the sections and remembers the offset and
12968 size of each of the DWP version 2 debugging sections that we are interested
12969 in. This is split into a separate function because we don't know if we
12970 have version 1 or 2 until we parse the cu_index/tu_index sections. */
12973 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
12975 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
12976 const struct dwop_section_names *names = &dwop_section_names;
12977 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
12979 /* Record the ELF section number for later lookup: this is what the
12980 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12981 gdb_assert (elf_section_nr < dwp_file->num_sections);
12982 dwp_file->elf_sections[elf_section_nr] = sectp;
12984 /* Look for specific sections that we need. */
12985 if (section_is_p (sectp->name, &names->abbrev_dwo))
12987 dwp_file->sections.abbrev.s.section = sectp;
12988 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
12990 else if (section_is_p (sectp->name, &names->info_dwo))
12992 dwp_file->sections.info.s.section = sectp;
12993 dwp_file->sections.info.size = bfd_get_section_size (sectp);
12995 else if (section_is_p (sectp->name, &names->line_dwo))
12997 dwp_file->sections.line.s.section = sectp;
12998 dwp_file->sections.line.size = bfd_get_section_size (sectp);
13000 else if (section_is_p (sectp->name, &names->loc_dwo))
13002 dwp_file->sections.loc.s.section = sectp;
13003 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13005 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13007 dwp_file->sections.macinfo.s.section = sectp;
13008 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13010 else if (section_is_p (sectp->name, &names->macro_dwo))
13012 dwp_file->sections.macro.s.section = sectp;
13013 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13015 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13017 dwp_file->sections.str_offsets.s.section = sectp;
13018 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13020 else if (section_is_p (sectp->name, &names->types_dwo))
13022 dwp_file->sections.types.s.section = sectp;
13023 dwp_file->sections.types.size = bfd_get_section_size (sectp);
13027 /* Hash function for dwp_file loaded CUs/TUs. */
13030 hash_dwp_loaded_cutus (const void *item)
13032 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13034 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13035 return dwo_unit->signature;
13038 /* Equality function for dwp_file loaded CUs/TUs. */
13041 eq_dwp_loaded_cutus (const void *a, const void *b)
13043 const struct dwo_unit *dua = (const struct dwo_unit *) a;
13044 const struct dwo_unit *dub = (const struct dwo_unit *) b;
13046 return dua->signature == dub->signature;
13049 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13052 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13054 return htab_create_alloc_ex (3,
13055 hash_dwp_loaded_cutus,
13056 eq_dwp_loaded_cutus,
13058 &objfile->objfile_obstack,
13059 hashtab_obstack_allocate,
13060 dummy_obstack_deallocate);
13063 /* Try to open DWP file FILE_NAME.
13064 The result is the bfd handle of the file.
13065 If there is a problem finding or opening the file, return NULL.
13066 Upon success, the canonicalized path of the file is stored in the bfd,
13067 same as symfile_bfd_open. */
13069 static gdb_bfd_ref_ptr
13070 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13071 const char *file_name)
13073 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13075 1 /*search_cwd*/));
13079 /* Work around upstream bug 15652.
13080 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13081 [Whether that's a "bug" is debatable, but it is getting in our way.]
13082 We have no real idea where the dwp file is, because gdb's realpath-ing
13083 of the executable's path may have discarded the needed info.
13084 [IWBN if the dwp file name was recorded in the executable, akin to
13085 .gnu_debuglink, but that doesn't exist yet.]
13086 Strip the directory from FILE_NAME and search again. */
13087 if (*debug_file_directory != '\0')
13089 /* Don't implicitly search the current directory here.
13090 If the user wants to search "." to handle this case,
13091 it must be added to debug-file-directory. */
13092 return try_open_dwop_file (dwarf2_per_objfile,
13093 lbasename (file_name), 1 /*is_dwp*/,
13100 /* Initialize the use of the DWP file for the current objfile.
13101 By convention the name of the DWP file is ${objfile}.dwp.
13102 The result is NULL if it can't be found. */
13104 static std::unique_ptr<struct dwp_file>
13105 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13107 struct objfile *objfile = dwarf2_per_objfile->objfile;
13109 /* Try to find first .dwp for the binary file before any symbolic links
13112 /* If the objfile is a debug file, find the name of the real binary
13113 file and get the name of dwp file from there. */
13114 std::string dwp_name;
13115 if (objfile->separate_debug_objfile_backlink != NULL)
13117 struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13118 const char *backlink_basename = lbasename (backlink->original_name);
13120 dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13123 dwp_name = objfile->original_name;
13125 dwp_name += ".dwp";
13127 gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13129 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13131 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13132 dwp_name = objfile_name (objfile);
13133 dwp_name += ".dwp";
13134 dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13139 if (dwarf_read_debug)
13140 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13141 return std::unique_ptr<dwp_file> ();
13144 const char *name = bfd_get_filename (dbfd.get ());
13145 std::unique_ptr<struct dwp_file> dwp_file
13146 (new struct dwp_file (name, std::move (dbfd)));
13148 /* +1: section 0 is unused */
13149 dwp_file->num_sections = bfd_count_sections (dwp_file->dbfd) + 1;
13150 dwp_file->elf_sections =
13151 OBSTACK_CALLOC (&objfile->objfile_obstack,
13152 dwp_file->num_sections, asection *);
13154 bfd_map_over_sections (dwp_file->dbfd.get (),
13155 dwarf2_locate_common_dwp_sections,
13158 dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13161 dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13164 /* The DWP file version is stored in the hash table. Oh well. */
13165 if (dwp_file->cus && dwp_file->tus
13166 && dwp_file->cus->version != dwp_file->tus->version)
13168 /* Technically speaking, we should try to limp along, but this is
13169 pretty bizarre. We use pulongest here because that's the established
13170 portability solution (e.g, we cannot use %u for uint32_t). */
13171 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13172 " TU version %s [in DWP file %s]"),
13173 pulongest (dwp_file->cus->version),
13174 pulongest (dwp_file->tus->version), dwp_name.c_str ());
13178 dwp_file->version = dwp_file->cus->version;
13179 else if (dwp_file->tus)
13180 dwp_file->version = dwp_file->tus->version;
13182 dwp_file->version = 2;
13184 if (dwp_file->version == 2)
13185 bfd_map_over_sections (dwp_file->dbfd.get (),
13186 dwarf2_locate_v2_dwp_sections,
13189 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13190 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13192 if (dwarf_read_debug)
13194 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13195 fprintf_unfiltered (gdb_stdlog,
13196 " %s CUs, %s TUs\n",
13197 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13198 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13204 /* Wrapper around open_and_init_dwp_file, only open it once. */
13206 static struct dwp_file *
13207 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13209 if (! dwarf2_per_objfile->dwp_checked)
13211 dwarf2_per_objfile->dwp_file
13212 = open_and_init_dwp_file (dwarf2_per_objfile);
13213 dwarf2_per_objfile->dwp_checked = 1;
13215 return dwarf2_per_objfile->dwp_file.get ();
13218 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13219 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13220 or in the DWP file for the objfile, referenced by THIS_UNIT.
13221 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13222 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13224 This is called, for example, when wanting to read a variable with a
13225 complex location. Therefore we don't want to do file i/o for every call.
13226 Therefore we don't want to look for a DWO file on every call.
13227 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13228 then we check if we've already seen DWO_NAME, and only THEN do we check
13231 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13232 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13234 static struct dwo_unit *
13235 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13236 const char *dwo_name, const char *comp_dir,
13237 ULONGEST signature, int is_debug_types)
13239 struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13240 struct objfile *objfile = dwarf2_per_objfile->objfile;
13241 const char *kind = is_debug_types ? "TU" : "CU";
13242 void **dwo_file_slot;
13243 struct dwo_file *dwo_file;
13244 struct dwp_file *dwp_file;
13246 /* First see if there's a DWP file.
13247 If we have a DWP file but didn't find the DWO inside it, don't
13248 look for the original DWO file. It makes gdb behave differently
13249 depending on whether one is debugging in the build tree. */
13251 dwp_file = get_dwp_file (dwarf2_per_objfile);
13252 if (dwp_file != NULL)
13254 const struct dwp_hash_table *dwp_htab =
13255 is_debug_types ? dwp_file->tus : dwp_file->cus;
13257 if (dwp_htab != NULL)
13259 struct dwo_unit *dwo_cutu =
13260 lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13261 signature, is_debug_types);
13263 if (dwo_cutu != NULL)
13265 if (dwarf_read_debug)
13267 fprintf_unfiltered (gdb_stdlog,
13268 "Virtual DWO %s %s found: @%s\n",
13269 kind, hex_string (signature),
13270 host_address_to_string (dwo_cutu));
13278 /* No DWP file, look for the DWO file. */
13280 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13281 dwo_name, comp_dir);
13282 if (*dwo_file_slot == NULL)
13284 /* Read in the file and build a table of the CUs/TUs it contains. */
13285 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13287 /* NOTE: This will be NULL if unable to open the file. */
13288 dwo_file = (struct dwo_file *) *dwo_file_slot;
13290 if (dwo_file != NULL)
13292 struct dwo_unit *dwo_cutu = NULL;
13294 if (is_debug_types && dwo_file->tus)
13296 struct dwo_unit find_dwo_cutu;
13298 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13299 find_dwo_cutu.signature = signature;
13301 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13303 else if (!is_debug_types && dwo_file->cus)
13305 struct dwo_unit find_dwo_cutu;
13307 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13308 find_dwo_cutu.signature = signature;
13309 dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13313 if (dwo_cutu != NULL)
13315 if (dwarf_read_debug)
13317 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13318 kind, dwo_name, hex_string (signature),
13319 host_address_to_string (dwo_cutu));
13326 /* We didn't find it. This could mean a dwo_id mismatch, or
13327 someone deleted the DWO/DWP file, or the search path isn't set up
13328 correctly to find the file. */
13330 if (dwarf_read_debug)
13332 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13333 kind, dwo_name, hex_string (signature));
13336 /* This is a warning and not a complaint because it can be caused by
13337 pilot error (e.g., user accidentally deleting the DWO). */
13339 /* Print the name of the DWP file if we looked there, helps the user
13340 better diagnose the problem. */
13341 std::string dwp_text;
13343 if (dwp_file != NULL)
13344 dwp_text = string_printf (" [in DWP file %s]",
13345 lbasename (dwp_file->name));
13347 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13348 " [in module %s]"),
13349 kind, dwo_name, hex_string (signature),
13351 this_unit->is_debug_types ? "TU" : "CU",
13352 sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13357 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13358 See lookup_dwo_cutu_unit for details. */
13360 static struct dwo_unit *
13361 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13362 const char *dwo_name, const char *comp_dir,
13363 ULONGEST signature)
13365 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13368 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13369 See lookup_dwo_cutu_unit for details. */
13371 static struct dwo_unit *
13372 lookup_dwo_type_unit (struct signatured_type *this_tu,
13373 const char *dwo_name, const char *comp_dir)
13375 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13378 /* Traversal function for queue_and_load_all_dwo_tus. */
13381 queue_and_load_dwo_tu (void **slot, void *info)
13383 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13384 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13385 ULONGEST signature = dwo_unit->signature;
13386 struct signatured_type *sig_type =
13387 lookup_dwo_signatured_type (per_cu->cu, signature);
13389 if (sig_type != NULL)
13391 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13393 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13394 a real dependency of PER_CU on SIG_TYPE. That is detected later
13395 while processing PER_CU. */
13396 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13397 load_full_type_unit (sig_cu);
13398 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13404 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13405 The DWO may have the only definition of the type, though it may not be
13406 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13407 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13410 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13412 struct dwo_unit *dwo_unit;
13413 struct dwo_file *dwo_file;
13415 gdb_assert (!per_cu->is_debug_types);
13416 gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13417 gdb_assert (per_cu->cu != NULL);
13419 dwo_unit = per_cu->cu->dwo_unit;
13420 gdb_assert (dwo_unit != NULL);
13422 dwo_file = dwo_unit->dwo_file;
13423 if (dwo_file->tus != NULL)
13424 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13427 /* Free all resources associated with DWO_FILE.
13428 Close the DWO file and munmap the sections. */
13431 free_dwo_file (struct dwo_file *dwo_file)
13433 /* Note: dbfd is NULL for virtual DWO files. */
13434 gdb_bfd_unref (dwo_file->dbfd);
13436 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13439 /* Traversal function for free_dwo_files. */
13442 free_dwo_file_from_slot (void **slot, void *info)
13444 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13446 free_dwo_file (dwo_file);
13451 /* Free all resources associated with DWO_FILES. */
13454 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13456 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13459 /* Read in various DIEs. */
13461 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13462 Inherit only the children of the DW_AT_abstract_origin DIE not being
13463 already referenced by DW_AT_abstract_origin from the children of the
13467 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13469 struct die_info *child_die;
13470 sect_offset *offsetp;
13471 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13472 struct die_info *origin_die;
13473 /* Iterator of the ORIGIN_DIE children. */
13474 struct die_info *origin_child_die;
13475 struct attribute *attr;
13476 struct dwarf2_cu *origin_cu;
13477 struct pending **origin_previous_list_in_scope;
13479 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13483 /* Note that following die references may follow to a die in a
13487 origin_die = follow_die_ref (die, attr, &origin_cu);
13489 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13491 origin_previous_list_in_scope = origin_cu->list_in_scope;
13492 origin_cu->list_in_scope = cu->list_in_scope;
13494 if (die->tag != origin_die->tag
13495 && !(die->tag == DW_TAG_inlined_subroutine
13496 && origin_die->tag == DW_TAG_subprogram))
13497 complaint (&symfile_complaints,
13498 _("DIE %s and its abstract origin %s have different tags"),
13499 sect_offset_str (die->sect_off),
13500 sect_offset_str (origin_die->sect_off));
13502 std::vector<sect_offset> offsets;
13504 for (child_die = die->child;
13505 child_die && child_die->tag;
13506 child_die = sibling_die (child_die))
13508 struct die_info *child_origin_die;
13509 struct dwarf2_cu *child_origin_cu;
13511 /* We are trying to process concrete instance entries:
13512 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13513 it's not relevant to our analysis here. i.e. detecting DIEs that are
13514 present in the abstract instance but not referenced in the concrete
13516 if (child_die->tag == DW_TAG_call_site
13517 || child_die->tag == DW_TAG_GNU_call_site)
13520 /* For each CHILD_DIE, find the corresponding child of
13521 ORIGIN_DIE. If there is more than one layer of
13522 DW_AT_abstract_origin, follow them all; there shouldn't be,
13523 but GCC versions at least through 4.4 generate this (GCC PR
13525 child_origin_die = child_die;
13526 child_origin_cu = cu;
13529 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13533 child_origin_die = follow_die_ref (child_origin_die, attr,
13537 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13538 counterpart may exist. */
13539 if (child_origin_die != child_die)
13541 if (child_die->tag != child_origin_die->tag
13542 && !(child_die->tag == DW_TAG_inlined_subroutine
13543 && child_origin_die->tag == DW_TAG_subprogram))
13544 complaint (&symfile_complaints,
13545 _("Child DIE %s and its abstract origin %s have "
13547 sect_offset_str (child_die->sect_off),
13548 sect_offset_str (child_origin_die->sect_off));
13549 if (child_origin_die->parent != origin_die)
13550 complaint (&symfile_complaints,
13551 _("Child DIE %s and its abstract origin %s have "
13552 "different parents"),
13553 sect_offset_str (child_die->sect_off),
13554 sect_offset_str (child_origin_die->sect_off));
13556 offsets.push_back (child_origin_die->sect_off);
13559 std::sort (offsets.begin (), offsets.end ());
13560 sect_offset *offsets_end = offsets.data () + offsets.size ();
13561 for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13562 if (offsetp[-1] == *offsetp)
13563 complaint (&symfile_complaints,
13564 _("Multiple children of DIE %s refer "
13565 "to DIE %s as their abstract origin"),
13566 sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13568 offsetp = offsets.data ();
13569 origin_child_die = origin_die->child;
13570 while (origin_child_die && origin_child_die->tag)
13572 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13573 while (offsetp < offsets_end
13574 && *offsetp < origin_child_die->sect_off)
13576 if (offsetp >= offsets_end
13577 || *offsetp > origin_child_die->sect_off)
13579 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13580 Check whether we're already processing ORIGIN_CHILD_DIE.
13581 This can happen with mutually referenced abstract_origins.
13583 if (!origin_child_die->in_process)
13584 process_die (origin_child_die, origin_cu);
13586 origin_child_die = sibling_die (origin_child_die);
13588 origin_cu->list_in_scope = origin_previous_list_in_scope;
13592 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13594 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13595 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13596 struct context_stack *newobj;
13599 struct die_info *child_die;
13600 struct attribute *attr, *call_line, *call_file;
13602 CORE_ADDR baseaddr;
13603 struct block *block;
13604 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13605 std::vector<struct symbol *> template_args;
13606 struct template_symbol *templ_func = NULL;
13610 /* If we do not have call site information, we can't show the
13611 caller of this inlined function. That's too confusing, so
13612 only use the scope for local variables. */
13613 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13614 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13615 if (call_line == NULL || call_file == NULL)
13617 read_lexical_block_scope (die, cu);
13622 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13624 name = dwarf2_name (die, cu);
13626 /* Ignore functions with missing or empty names. These are actually
13627 illegal according to the DWARF standard. */
13630 complaint (&symfile_complaints,
13631 _("missing name for subprogram DIE at %s"),
13632 sect_offset_str (die->sect_off));
13636 /* Ignore functions with missing or invalid low and high pc attributes. */
13637 if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13638 <= PC_BOUNDS_INVALID)
13640 attr = dwarf2_attr (die, DW_AT_external, cu);
13641 if (!attr || !DW_UNSND (attr))
13642 complaint (&symfile_complaints,
13643 _("cannot get low and high bounds "
13644 "for subprogram DIE at %s"),
13645 sect_offset_str (die->sect_off));
13649 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13650 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13652 /* If we have any template arguments, then we must allocate a
13653 different sort of symbol. */
13654 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13656 if (child_die->tag == DW_TAG_template_type_param
13657 || child_die->tag == DW_TAG_template_value_param)
13659 templ_func = allocate_template_symbol (objfile);
13660 templ_func->subclass = SYMBOL_TEMPLATE;
13665 newobj = push_context (0, lowpc);
13666 newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13667 (struct symbol *) templ_func);
13669 /* If there is a location expression for DW_AT_frame_base, record
13671 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13673 dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13675 /* If there is a location for the static link, record it. */
13676 newobj->static_link = NULL;
13677 attr = dwarf2_attr (die, DW_AT_static_link, cu);
13680 newobj->static_link
13681 = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13682 attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13685 cu->list_in_scope = &local_symbols;
13687 if (die->child != NULL)
13689 child_die = die->child;
13690 while (child_die && child_die->tag)
13692 if (child_die->tag == DW_TAG_template_type_param
13693 || child_die->tag == DW_TAG_template_value_param)
13695 struct symbol *arg = new_symbol (child_die, NULL, cu);
13698 template_args.push_back (arg);
13701 process_die (child_die, cu);
13702 child_die = sibling_die (child_die);
13706 inherit_abstract_dies (die, cu);
13708 /* If we have a DW_AT_specification, we might need to import using
13709 directives from the context of the specification DIE. See the
13710 comment in determine_prefix. */
13711 if (cu->language == language_cplus
13712 && dwarf2_attr (die, DW_AT_specification, cu))
13714 struct dwarf2_cu *spec_cu = cu;
13715 struct die_info *spec_die = die_specification (die, &spec_cu);
13719 child_die = spec_die->child;
13720 while (child_die && child_die->tag)
13722 if (child_die->tag == DW_TAG_imported_module)
13723 process_die (child_die, spec_cu);
13724 child_die = sibling_die (child_die);
13727 /* In some cases, GCC generates specification DIEs that
13728 themselves contain DW_AT_specification attributes. */
13729 spec_die = die_specification (spec_die, &spec_cu);
13733 newobj = pop_context ();
13734 /* Make a block for the local symbols within. */
13735 block = finish_block (newobj->name, &local_symbols, newobj->old_blocks,
13736 newobj->static_link, lowpc, highpc);
13738 /* For C++, set the block's scope. */
13739 if ((cu->language == language_cplus
13740 || cu->language == language_fortran
13741 || cu->language == language_d
13742 || cu->language == language_rust)
13743 && cu->processing_has_namespace_info)
13744 block_set_scope (block, determine_prefix (die, cu),
13745 &objfile->objfile_obstack);
13747 /* If we have address ranges, record them. */
13748 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13750 gdbarch_make_symbol_special (gdbarch, newobj->name, objfile);
13752 /* Attach template arguments to function. */
13753 if (!template_args.empty ())
13755 gdb_assert (templ_func != NULL);
13757 templ_func->n_template_arguments = template_args.size ();
13758 templ_func->template_arguments
13759 = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13760 templ_func->n_template_arguments);
13761 memcpy (templ_func->template_arguments,
13762 template_args.data (),
13763 (templ_func->n_template_arguments * sizeof (struct symbol *)));
13766 /* In C++, we can have functions nested inside functions (e.g., when
13767 a function declares a class that has methods). This means that
13768 when we finish processing a function scope, we may need to go
13769 back to building a containing block's symbol lists. */
13770 local_symbols = newobj->locals;
13771 local_using_directives = newobj->local_using_directives;
13773 /* If we've finished processing a top-level function, subsequent
13774 symbols go in the file symbol list. */
13775 if (outermost_context_p ())
13776 cu->list_in_scope = &file_symbols;
13779 /* Process all the DIES contained within a lexical block scope. Start
13780 a new scope, process the dies, and then close the scope. */
13783 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13785 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13786 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13787 struct context_stack *newobj;
13788 CORE_ADDR lowpc, highpc;
13789 struct die_info *child_die;
13790 CORE_ADDR baseaddr;
13792 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13794 /* Ignore blocks with missing or invalid low and high pc attributes. */
13795 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13796 as multiple lexical blocks? Handling children in a sane way would
13797 be nasty. Might be easier to properly extend generic blocks to
13798 describe ranges. */
13799 switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13801 case PC_BOUNDS_NOT_PRESENT:
13802 /* DW_TAG_lexical_block has no attributes, process its children as if
13803 there was no wrapping by that DW_TAG_lexical_block.
13804 GCC does no longer produces such DWARF since GCC r224161. */
13805 for (child_die = die->child;
13806 child_die != NULL && child_die->tag;
13807 child_die = sibling_die (child_die))
13808 process_die (child_die, cu);
13810 case PC_BOUNDS_INVALID:
13813 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13814 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13816 push_context (0, lowpc);
13817 if (die->child != NULL)
13819 child_die = die->child;
13820 while (child_die && child_die->tag)
13822 process_die (child_die, cu);
13823 child_die = sibling_die (child_die);
13826 inherit_abstract_dies (die, cu);
13827 newobj = pop_context ();
13829 if (local_symbols != NULL || local_using_directives != NULL)
13831 struct block *block
13832 = finish_block (0, &local_symbols, newobj->old_blocks, NULL,
13833 newobj->start_addr, highpc);
13835 /* Note that recording ranges after traversing children, as we
13836 do here, means that recording a parent's ranges entails
13837 walking across all its children's ranges as they appear in
13838 the address map, which is quadratic behavior.
13840 It would be nicer to record the parent's ranges before
13841 traversing its children, simply overriding whatever you find
13842 there. But since we don't even decide whether to create a
13843 block until after we've traversed its children, that's hard
13845 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13847 local_symbols = newobj->locals;
13848 local_using_directives = newobj->local_using_directives;
13851 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13854 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13856 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13857 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13858 CORE_ADDR pc, baseaddr;
13859 struct attribute *attr;
13860 struct call_site *call_site, call_site_local;
13863 struct die_info *child_die;
13865 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13867 attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13870 /* This was a pre-DWARF-5 GNU extension alias
13871 for DW_AT_call_return_pc. */
13872 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13876 complaint (&symfile_complaints,
13877 _("missing DW_AT_call_return_pc for DW_TAG_call_site "
13878 "DIE %s [in module %s]"),
13879 sect_offset_str (die->sect_off), objfile_name (objfile));
13882 pc = attr_value_as_address (attr) + baseaddr;
13883 pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13885 if (cu->call_site_htab == NULL)
13886 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13887 NULL, &objfile->objfile_obstack,
13888 hashtab_obstack_allocate, NULL);
13889 call_site_local.pc = pc;
13890 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13893 complaint (&symfile_complaints,
13894 _("Duplicate PC %s for DW_TAG_call_site "
13895 "DIE %s [in module %s]"),
13896 paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13897 objfile_name (objfile));
13901 /* Count parameters at the caller. */
13904 for (child_die = die->child; child_die && child_die->tag;
13905 child_die = sibling_die (child_die))
13907 if (child_die->tag != DW_TAG_call_site_parameter
13908 && child_die->tag != DW_TAG_GNU_call_site_parameter)
13910 complaint (&symfile_complaints,
13911 _("Tag %d is not DW_TAG_call_site_parameter in "
13912 "DW_TAG_call_site child DIE %s [in module %s]"),
13913 child_die->tag, sect_offset_str (child_die->sect_off),
13914 objfile_name (objfile));
13922 = ((struct call_site *)
13923 obstack_alloc (&objfile->objfile_obstack,
13924 sizeof (*call_site)
13925 + (sizeof (*call_site->parameter) * (nparams - 1))));
13927 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
13928 call_site->pc = pc;
13930 if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
13931 || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
13933 struct die_info *func_die;
13935 /* Skip also over DW_TAG_inlined_subroutine. */
13936 for (func_die = die->parent;
13937 func_die && func_die->tag != DW_TAG_subprogram
13938 && func_die->tag != DW_TAG_subroutine_type;
13939 func_die = func_die->parent);
13941 /* DW_AT_call_all_calls is a superset
13942 of DW_AT_call_all_tail_calls. */
13944 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
13945 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
13946 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
13947 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
13949 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13950 not complete. But keep CALL_SITE for look ups via call_site_htab,
13951 both the initial caller containing the real return address PC and
13952 the final callee containing the current PC of a chain of tail
13953 calls do not need to have the tail call list complete. But any
13954 function candidate for a virtual tail call frame searched via
13955 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13956 determined unambiguously. */
13960 struct type *func_type = NULL;
13963 func_type = get_die_type (func_die, cu);
13964 if (func_type != NULL)
13966 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
13968 /* Enlist this call site to the function. */
13969 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
13970 TYPE_TAIL_CALL_LIST (func_type) = call_site;
13973 complaint (&symfile_complaints,
13974 _("Cannot find function owning DW_TAG_call_site "
13975 "DIE %s [in module %s]"),
13976 sect_offset_str (die->sect_off), objfile_name (objfile));
13980 attr = dwarf2_attr (die, DW_AT_call_target, cu);
13982 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
13984 attr = dwarf2_attr (die, DW_AT_call_origin, cu);
13987 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13988 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13990 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
13991 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
13992 /* Keep NULL DWARF_BLOCK. */;
13993 else if (attr_form_is_block (attr))
13995 struct dwarf2_locexpr_baton *dlbaton;
13997 dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
13998 dlbaton->data = DW_BLOCK (attr)->data;
13999 dlbaton->size = DW_BLOCK (attr)->size;
14000 dlbaton->per_cu = cu->per_cu;
14002 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14004 else if (attr_form_is_ref (attr))
14006 struct dwarf2_cu *target_cu = cu;
14007 struct die_info *target_die;
14009 target_die = follow_die_ref (die, attr, &target_cu);
14010 gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14011 if (die_is_declaration (target_die, target_cu))
14013 const char *target_physname;
14015 /* Prefer the mangled name; otherwise compute the demangled one. */
14016 target_physname = dw2_linkage_name (target_die, target_cu);
14017 if (target_physname == NULL)
14018 target_physname = dwarf2_physname (NULL, target_die, target_cu);
14019 if (target_physname == NULL)
14020 complaint (&symfile_complaints,
14021 _("DW_AT_call_target target DIE has invalid "
14022 "physname, for referencing DIE %s [in module %s]"),
14023 sect_offset_str (die->sect_off), objfile_name (objfile));
14025 SET_FIELD_PHYSNAME (call_site->target, target_physname);
14031 /* DW_AT_entry_pc should be preferred. */
14032 if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14033 <= PC_BOUNDS_INVALID)
14034 complaint (&symfile_complaints,
14035 _("DW_AT_call_target target DIE has invalid "
14036 "low pc, for referencing DIE %s [in module %s]"),
14037 sect_offset_str (die->sect_off), objfile_name (objfile));
14040 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14041 SET_FIELD_PHYSADDR (call_site->target, lowpc);
14046 complaint (&symfile_complaints,
14047 _("DW_TAG_call_site DW_AT_call_target is neither "
14048 "block nor reference, for DIE %s [in module %s]"),
14049 sect_offset_str (die->sect_off), objfile_name (objfile));
14051 call_site->per_cu = cu->per_cu;
14053 for (child_die = die->child;
14054 child_die && child_die->tag;
14055 child_die = sibling_die (child_die))
14057 struct call_site_parameter *parameter;
14058 struct attribute *loc, *origin;
14060 if (child_die->tag != DW_TAG_call_site_parameter
14061 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14063 /* Already printed the complaint above. */
14067 gdb_assert (call_site->parameter_count < nparams);
14068 parameter = &call_site->parameter[call_site->parameter_count];
14070 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14071 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14072 register is contained in DW_AT_call_value. */
14074 loc = dwarf2_attr (child_die, DW_AT_location, cu);
14075 origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14076 if (origin == NULL)
14078 /* This was a pre-DWARF-5 GNU extension alias
14079 for DW_AT_call_parameter. */
14080 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14082 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14084 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14086 sect_offset sect_off
14087 = (sect_offset) dwarf2_get_ref_die_offset (origin);
14088 if (!offset_in_cu_p (&cu->header, sect_off))
14090 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14091 binding can be done only inside one CU. Such referenced DIE
14092 therefore cannot be even moved to DW_TAG_partial_unit. */
14093 complaint (&symfile_complaints,
14094 _("DW_AT_call_parameter offset is not in CU for "
14095 "DW_TAG_call_site child DIE %s [in module %s]"),
14096 sect_offset_str (child_die->sect_off),
14097 objfile_name (objfile));
14100 parameter->u.param_cu_off
14101 = (cu_offset) (sect_off - cu->header.sect_off);
14103 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14105 complaint (&symfile_complaints,
14106 _("No DW_FORM_block* DW_AT_location for "
14107 "DW_TAG_call_site child DIE %s [in module %s]"),
14108 sect_offset_str (child_die->sect_off), objfile_name (objfile));
14113 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14114 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14115 if (parameter->u.dwarf_reg != -1)
14116 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14117 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14118 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14119 ¶meter->u.fb_offset))
14120 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14123 complaint (&symfile_complaints,
14124 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
14125 "for DW_FORM_block* DW_AT_location is supported for "
14126 "DW_TAG_call_site child DIE %s "
14128 sect_offset_str (child_die->sect_off),
14129 objfile_name (objfile));
14134 attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14136 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14137 if (!attr_form_is_block (attr))
14139 complaint (&symfile_complaints,
14140 _("No DW_FORM_block* DW_AT_call_value for "
14141 "DW_TAG_call_site child DIE %s [in module %s]"),
14142 sect_offset_str (child_die->sect_off),
14143 objfile_name (objfile));
14146 parameter->value = DW_BLOCK (attr)->data;
14147 parameter->value_size = DW_BLOCK (attr)->size;
14149 /* Parameters are not pre-cleared by memset above. */
14150 parameter->data_value = NULL;
14151 parameter->data_value_size = 0;
14152 call_site->parameter_count++;
14154 attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14156 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14159 if (!attr_form_is_block (attr))
14160 complaint (&symfile_complaints,
14161 _("No DW_FORM_block* DW_AT_call_data_value for "
14162 "DW_TAG_call_site child DIE %s [in module %s]"),
14163 sect_offset_str (child_die->sect_off),
14164 objfile_name (objfile));
14167 parameter->data_value = DW_BLOCK (attr)->data;
14168 parameter->data_value_size = DW_BLOCK (attr)->size;
14174 /* Helper function for read_variable. If DIE represents a virtual
14175 table, then return the type of the concrete object that is
14176 associated with the virtual table. Otherwise, return NULL. */
14178 static struct type *
14179 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14181 struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14185 /* Find the type DIE. */
14186 struct die_info *type_die = NULL;
14187 struct dwarf2_cu *type_cu = cu;
14189 if (attr_form_is_ref (attr))
14190 type_die = follow_die_ref (die, attr, &type_cu);
14191 if (type_die == NULL)
14194 if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14196 return die_containing_type (type_die, type_cu);
14199 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14202 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14204 struct rust_vtable_symbol *storage = NULL;
14206 if (cu->language == language_rust)
14208 struct type *containing_type = rust_containing_type (die, cu);
14210 if (containing_type != NULL)
14212 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14214 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14215 struct rust_vtable_symbol);
14216 initialize_objfile_symbol (storage);
14217 storage->concrete_type = containing_type;
14218 storage->subclass = SYMBOL_RUST_VTABLE;
14222 new_symbol (die, NULL, cu, storage);
14225 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14226 reading .debug_rnglists.
14227 Callback's type should be:
14228 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14229 Return true if the attributes are present and valid, otherwise,
14232 template <typename Callback>
14234 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14235 Callback &&callback)
14237 struct dwarf2_per_objfile *dwarf2_per_objfile
14238 = cu->per_cu->dwarf2_per_objfile;
14239 struct objfile *objfile = dwarf2_per_objfile->objfile;
14240 bfd *obfd = objfile->obfd;
14241 /* Base address selection entry. */
14244 const gdb_byte *buffer;
14245 CORE_ADDR baseaddr;
14246 bool overflow = false;
14248 found_base = cu->base_known;
14249 base = cu->base_address;
14251 dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14252 if (offset >= dwarf2_per_objfile->rnglists.size)
14254 complaint (&symfile_complaints,
14255 _("Offset %d out of bounds for DW_AT_ranges attribute"),
14259 buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14261 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14265 /* Initialize it due to a false compiler warning. */
14266 CORE_ADDR range_beginning = 0, range_end = 0;
14267 const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14268 + dwarf2_per_objfile->rnglists.size);
14269 unsigned int bytes_read;
14271 if (buffer == buf_end)
14276 const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14279 case DW_RLE_end_of_list:
14281 case DW_RLE_base_address:
14282 if (buffer + cu->header.addr_size > buf_end)
14287 base = read_address (obfd, buffer, cu, &bytes_read);
14289 buffer += bytes_read;
14291 case DW_RLE_start_length:
14292 if (buffer + cu->header.addr_size > buf_end)
14297 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14298 buffer += bytes_read;
14299 range_end = (range_beginning
14300 + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14301 buffer += bytes_read;
14302 if (buffer > buf_end)
14308 case DW_RLE_offset_pair:
14309 range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14310 buffer += bytes_read;
14311 if (buffer > buf_end)
14316 range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14317 buffer += bytes_read;
14318 if (buffer > buf_end)
14324 case DW_RLE_start_end:
14325 if (buffer + 2 * cu->header.addr_size > buf_end)
14330 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14331 buffer += bytes_read;
14332 range_end = read_address (obfd, buffer, cu, &bytes_read);
14333 buffer += bytes_read;
14336 complaint (&symfile_complaints,
14337 _("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 (&symfile_complaints,
14350 _("Invalid .debug_rnglists data (no base address)"));
14354 if (range_beginning > range_end)
14356 /* Inverted range entries are invalid. */
14357 complaint (&symfile_complaints,
14358 _("Invalid .debug_rnglists data (inverted range)"));
14362 /* Empty range entries have no effect. */
14363 if (range_beginning == range_end)
14366 range_beginning += base;
14369 /* A not-uncommon case of bad debug info.
14370 Don't pollute the addrmap with bad data. */
14371 if (range_beginning + baseaddr == 0
14372 && !dwarf2_per_objfile->has_section_at_zero)
14374 complaint (&symfile_complaints,
14375 _(".debug_rnglists entry has start address of zero"
14376 " [in module %s]"), objfile_name (objfile));
14380 callback (range_beginning, range_end);
14385 complaint (&symfile_complaints,
14386 _("Offset %d is not terminated "
14387 "for DW_AT_ranges attribute"),
14395 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14396 Callback's type should be:
14397 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14398 Return 1 if the attributes are present and valid, otherwise, return 0. */
14400 template <typename Callback>
14402 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14403 Callback &&callback)
14405 struct dwarf2_per_objfile *dwarf2_per_objfile
14406 = cu->per_cu->dwarf2_per_objfile;
14407 struct objfile *objfile = dwarf2_per_objfile->objfile;
14408 struct comp_unit_head *cu_header = &cu->header;
14409 bfd *obfd = objfile->obfd;
14410 unsigned int addr_size = cu_header->addr_size;
14411 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14412 /* Base address selection entry. */
14415 unsigned int dummy;
14416 const gdb_byte *buffer;
14417 CORE_ADDR baseaddr;
14419 if (cu_header->version >= 5)
14420 return dwarf2_rnglists_process (offset, cu, callback);
14422 found_base = cu->base_known;
14423 base = cu->base_address;
14425 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14426 if (offset >= dwarf2_per_objfile->ranges.size)
14428 complaint (&symfile_complaints,
14429 _("Offset %d out of bounds for DW_AT_ranges attribute"),
14433 buffer = dwarf2_per_objfile->ranges.buffer + offset;
14435 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14439 CORE_ADDR range_beginning, range_end;
14441 range_beginning = read_address (obfd, buffer, cu, &dummy);
14442 buffer += addr_size;
14443 range_end = read_address (obfd, buffer, cu, &dummy);
14444 buffer += addr_size;
14445 offset += 2 * addr_size;
14447 /* An end of list marker is a pair of zero addresses. */
14448 if (range_beginning == 0 && range_end == 0)
14449 /* Found the end of list entry. */
14452 /* Each base address selection entry is a pair of 2 values.
14453 The first is the largest possible address, the second is
14454 the base address. Check for a base address here. */
14455 if ((range_beginning & mask) == mask)
14457 /* If we found the largest possible address, then we already
14458 have the base address in range_end. */
14466 /* We have no valid base address for the ranges
14468 complaint (&symfile_complaints,
14469 _("Invalid .debug_ranges data (no base address)"));
14473 if (range_beginning > range_end)
14475 /* Inverted range entries are invalid. */
14476 complaint (&symfile_complaints,
14477 _("Invalid .debug_ranges data (inverted range)"));
14481 /* Empty range entries have no effect. */
14482 if (range_beginning == range_end)
14485 range_beginning += base;
14488 /* A not-uncommon case of bad debug info.
14489 Don't pollute the addrmap with bad data. */
14490 if (range_beginning + baseaddr == 0
14491 && !dwarf2_per_objfile->has_section_at_zero)
14493 complaint (&symfile_complaints,
14494 _(".debug_ranges entry has start address of zero"
14495 " [in module %s]"), objfile_name (objfile));
14499 callback (range_beginning, range_end);
14505 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14506 Return 1 if the attributes are present and valid, otherwise, return 0.
14507 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14510 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14511 CORE_ADDR *high_return, struct dwarf2_cu *cu,
14512 struct partial_symtab *ranges_pst)
14514 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14515 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14516 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14517 SECT_OFF_TEXT (objfile));
14520 CORE_ADDR high = 0;
14523 retval = dwarf2_ranges_process (offset, cu,
14524 [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14526 if (ranges_pst != NULL)
14531 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch,
14532 range_beginning + baseaddr);
14533 highpc = gdbarch_adjust_dwarf2_addr (gdbarch,
14534 range_end + baseaddr);
14535 addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
14539 /* FIXME: This is recording everything as a low-high
14540 segment of consecutive addresses. We should have a
14541 data structure for discontiguous block ranges
14545 low = range_beginning;
14551 if (range_beginning < low)
14552 low = range_beginning;
14553 if (range_end > high)
14561 /* If the first entry is an end-of-list marker, the range
14562 describes an empty scope, i.e. no instructions. */
14568 *high_return = high;
14572 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14573 definition for the return value. *LOWPC and *HIGHPC are set iff
14574 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14576 static enum pc_bounds_kind
14577 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14578 CORE_ADDR *highpc, struct dwarf2_cu *cu,
14579 struct partial_symtab *pst)
14581 struct dwarf2_per_objfile *dwarf2_per_objfile
14582 = cu->per_cu->dwarf2_per_objfile;
14583 struct attribute *attr;
14584 struct attribute *attr_high;
14586 CORE_ADDR high = 0;
14587 enum pc_bounds_kind ret;
14589 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14592 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14595 low = attr_value_as_address (attr);
14596 high = attr_value_as_address (attr_high);
14597 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14601 /* Found high w/o low attribute. */
14602 return PC_BOUNDS_INVALID;
14604 /* Found consecutive range of addresses. */
14605 ret = PC_BOUNDS_HIGH_LOW;
14609 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14612 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14613 We take advantage of the fact that DW_AT_ranges does not appear
14614 in DW_TAG_compile_unit of DWO files. */
14615 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14616 unsigned int ranges_offset = (DW_UNSND (attr)
14617 + (need_ranges_base
14621 /* Value of the DW_AT_ranges attribute is the offset in the
14622 .debug_ranges section. */
14623 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14624 return PC_BOUNDS_INVALID;
14625 /* Found discontinuous range of addresses. */
14626 ret = PC_BOUNDS_RANGES;
14629 return PC_BOUNDS_NOT_PRESENT;
14632 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14634 return PC_BOUNDS_INVALID;
14636 /* When using the GNU linker, .gnu.linkonce. sections are used to
14637 eliminate duplicate copies of functions and vtables and such.
14638 The linker will arbitrarily choose one and discard the others.
14639 The AT_*_pc values for such functions refer to local labels in
14640 these sections. If the section from that file was discarded, the
14641 labels are not in the output, so the relocs get a value of 0.
14642 If this is a discarded function, mark the pc bounds as invalid,
14643 so that GDB will ignore it. */
14644 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14645 return PC_BOUNDS_INVALID;
14653 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14654 its low and high PC addresses. Do nothing if these addresses could not
14655 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14656 and HIGHPC to the high address if greater than HIGHPC. */
14659 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14660 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14661 struct dwarf2_cu *cu)
14663 CORE_ADDR low, high;
14664 struct die_info *child = die->child;
14666 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14668 *lowpc = std::min (*lowpc, low);
14669 *highpc = std::max (*highpc, high);
14672 /* If the language does not allow nested subprograms (either inside
14673 subprograms or lexical blocks), we're done. */
14674 if (cu->language != language_ada)
14677 /* Check all the children of the given DIE. If it contains nested
14678 subprograms, then check their pc bounds. Likewise, we need to
14679 check lexical blocks as well, as they may also contain subprogram
14681 while (child && child->tag)
14683 if (child->tag == DW_TAG_subprogram
14684 || child->tag == DW_TAG_lexical_block)
14685 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14686 child = sibling_die (child);
14690 /* Get the low and high pc's represented by the scope DIE, and store
14691 them in *LOWPC and *HIGHPC. If the correct values can't be
14692 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14695 get_scope_pc_bounds (struct die_info *die,
14696 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14697 struct dwarf2_cu *cu)
14699 CORE_ADDR best_low = (CORE_ADDR) -1;
14700 CORE_ADDR best_high = (CORE_ADDR) 0;
14701 CORE_ADDR current_low, current_high;
14703 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
14704 >= PC_BOUNDS_RANGES)
14706 best_low = current_low;
14707 best_high = current_high;
14711 struct die_info *child = die->child;
14713 while (child && child->tag)
14715 switch (child->tag) {
14716 case DW_TAG_subprogram:
14717 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14719 case DW_TAG_namespace:
14720 case DW_TAG_module:
14721 /* FIXME: carlton/2004-01-16: Should we do this for
14722 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14723 that current GCC's always emit the DIEs corresponding
14724 to definitions of methods of classes as children of a
14725 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14726 the DIEs giving the declarations, which could be
14727 anywhere). But I don't see any reason why the
14728 standards says that they have to be there. */
14729 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
14731 if (current_low != ((CORE_ADDR) -1))
14733 best_low = std::min (best_low, current_low);
14734 best_high = std::max (best_high, current_high);
14742 child = sibling_die (child);
14747 *highpc = best_high;
14750 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14754 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14755 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14757 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14758 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14759 struct attribute *attr;
14760 struct attribute *attr_high;
14762 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14765 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14768 CORE_ADDR low = attr_value_as_address (attr);
14769 CORE_ADDR high = attr_value_as_address (attr_high);
14771 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14774 low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14775 high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14776 record_block_range (block, low, high - 1);
14780 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14783 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14784 We take advantage of the fact that DW_AT_ranges does not appear
14785 in DW_TAG_compile_unit of DWO files. */
14786 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14788 /* The value of the DW_AT_ranges attribute is the offset of the
14789 address range list in the .debug_ranges section. */
14790 unsigned long offset = (DW_UNSND (attr)
14791 + (need_ranges_base ? cu->ranges_base : 0));
14793 dwarf2_ranges_process (offset, cu,
14794 [&] (CORE_ADDR start, CORE_ADDR end)
14798 start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14799 end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14800 record_block_range (block, start, end - 1);
14805 /* Check whether the producer field indicates either of GCC < 4.6, or the
14806 Intel C/C++ compiler, and cache the result in CU. */
14809 check_producer (struct dwarf2_cu *cu)
14813 if (cu->producer == NULL)
14815 /* For unknown compilers expect their behavior is DWARF version
14818 GCC started to support .debug_types sections by -gdwarf-4 since
14819 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14820 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14821 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14822 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14824 else if (producer_is_gcc (cu->producer, &major, &minor))
14826 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14827 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14829 else if (producer_is_icc (cu->producer, &major, &minor))
14830 cu->producer_is_icc_lt_14 = major < 14;
14833 /* For other non-GCC compilers, expect their behavior is DWARF version
14837 cu->checked_producer = 1;
14840 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14841 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14842 during 4.6.0 experimental. */
14845 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14847 if (!cu->checked_producer)
14848 check_producer (cu);
14850 return cu->producer_is_gxx_lt_4_6;
14853 /* Return the default accessibility type if it is not overriden by
14854 DW_AT_accessibility. */
14856 static enum dwarf_access_attribute
14857 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14859 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14861 /* The default DWARF 2 accessibility for members is public, the default
14862 accessibility for inheritance is private. */
14864 if (die->tag != DW_TAG_inheritance)
14865 return DW_ACCESS_public;
14867 return DW_ACCESS_private;
14871 /* DWARF 3+ defines the default accessibility a different way. The same
14872 rules apply now for DW_TAG_inheritance as for the members and it only
14873 depends on the container kind. */
14875 if (die->parent->tag == DW_TAG_class_type)
14876 return DW_ACCESS_private;
14878 return DW_ACCESS_public;
14882 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14883 offset. If the attribute was not found return 0, otherwise return
14884 1. If it was found but could not properly be handled, set *OFFSET
14888 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14891 struct attribute *attr;
14893 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14898 /* Note that we do not check for a section offset first here.
14899 This is because DW_AT_data_member_location is new in DWARF 4,
14900 so if we see it, we can assume that a constant form is really
14901 a constant and not a section offset. */
14902 if (attr_form_is_constant (attr))
14903 *offset = dwarf2_get_attr_constant_value (attr, 0);
14904 else if (attr_form_is_section_offset (attr))
14905 dwarf2_complex_location_expr_complaint ();
14906 else if (attr_form_is_block (attr))
14907 *offset = decode_locdesc (DW_BLOCK (attr), cu);
14909 dwarf2_complex_location_expr_complaint ();
14917 /* Add an aggregate field to the field list. */
14920 dwarf2_add_field (struct field_info *fip, struct die_info *die,
14921 struct dwarf2_cu *cu)
14923 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14924 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14925 struct nextfield *new_field;
14926 struct attribute *attr;
14928 const char *fieldname = "";
14930 if (die->tag == DW_TAG_inheritance)
14932 fip->baseclasses.emplace_back ();
14933 new_field = &fip->baseclasses.back ();
14937 fip->fields.emplace_back ();
14938 new_field = &fip->fields.back ();
14943 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
14945 new_field->accessibility = DW_UNSND (attr);
14947 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
14948 if (new_field->accessibility != DW_ACCESS_public)
14949 fip->non_public_fields = 1;
14951 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
14953 new_field->virtuality = DW_UNSND (attr);
14955 new_field->virtuality = DW_VIRTUALITY_none;
14957 fp = &new_field->field;
14959 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
14963 /* Data member other than a C++ static data member. */
14965 /* Get type of field. */
14966 fp->type = die_type (die, cu);
14968 SET_FIELD_BITPOS (*fp, 0);
14970 /* Get bit size of field (zero if none). */
14971 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
14974 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
14978 FIELD_BITSIZE (*fp) = 0;
14981 /* Get bit offset of field. */
14982 if (handle_data_member_location (die, cu, &offset))
14983 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
14984 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
14987 if (gdbarch_bits_big_endian (gdbarch))
14989 /* For big endian bits, the DW_AT_bit_offset gives the
14990 additional bit offset from the MSB of the containing
14991 anonymous object to the MSB of the field. We don't
14992 have to do anything special since we don't need to
14993 know the size of the anonymous object. */
14994 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
14998 /* For little endian bits, compute the bit offset to the
14999 MSB of the anonymous object, subtract off the number of
15000 bits from the MSB of the field to the MSB of the
15001 object, and then subtract off the number of bits of
15002 the field itself. The result is the bit offset of
15003 the LSB of the field. */
15004 int anonymous_size;
15005 int bit_offset = DW_UNSND (attr);
15007 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15010 /* The size of the anonymous object containing
15011 the bit field is explicit, so use the
15012 indicated size (in bytes). */
15013 anonymous_size = DW_UNSND (attr);
15017 /* The size of the anonymous object containing
15018 the bit field must be inferred from the type
15019 attribute of the data member containing the
15021 anonymous_size = TYPE_LENGTH (fp->type);
15023 SET_FIELD_BITPOS (*fp,
15024 (FIELD_BITPOS (*fp)
15025 + anonymous_size * bits_per_byte
15026 - bit_offset - FIELD_BITSIZE (*fp)));
15029 attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15031 SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15032 + dwarf2_get_attr_constant_value (attr, 0)));
15034 /* Get name of field. */
15035 fieldname = dwarf2_name (die, cu);
15036 if (fieldname == NULL)
15039 /* The name is already allocated along with this objfile, so we don't
15040 need to duplicate it for the type. */
15041 fp->name = fieldname;
15043 /* Change accessibility for artificial fields (e.g. virtual table
15044 pointer or virtual base class pointer) to private. */
15045 if (dwarf2_attr (die, DW_AT_artificial, cu))
15047 FIELD_ARTIFICIAL (*fp) = 1;
15048 new_field->accessibility = DW_ACCESS_private;
15049 fip->non_public_fields = 1;
15052 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15054 /* C++ static member. */
15056 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15057 is a declaration, but all versions of G++ as of this writing
15058 (so through at least 3.2.1) incorrectly generate
15059 DW_TAG_variable tags. */
15061 const char *physname;
15063 /* Get name of field. */
15064 fieldname = dwarf2_name (die, cu);
15065 if (fieldname == NULL)
15068 attr = dwarf2_attr (die, DW_AT_const_value, cu);
15070 /* Only create a symbol if this is an external value.
15071 new_symbol checks this and puts the value in the global symbol
15072 table, which we want. If it is not external, new_symbol
15073 will try to put the value in cu->list_in_scope which is wrong. */
15074 && dwarf2_flag_true_p (die, DW_AT_external, cu))
15076 /* A static const member, not much different than an enum as far as
15077 we're concerned, except that we can support more types. */
15078 new_symbol (die, NULL, cu);
15081 /* Get physical name. */
15082 physname = dwarf2_physname (fieldname, die, cu);
15084 /* The name is already allocated along with this objfile, so we don't
15085 need to duplicate it for the type. */
15086 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15087 FIELD_TYPE (*fp) = die_type (die, cu);
15088 FIELD_NAME (*fp) = fieldname;
15090 else if (die->tag == DW_TAG_inheritance)
15094 /* C++ base class field. */
15095 if (handle_data_member_location (die, cu, &offset))
15096 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15097 FIELD_BITSIZE (*fp) = 0;
15098 FIELD_TYPE (*fp) = die_type (die, cu);
15099 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
15101 else if (die->tag == DW_TAG_variant_part)
15103 /* process_structure_scope will treat this DIE as a union. */
15104 process_structure_scope (die, cu);
15106 /* The variant part is relative to the start of the enclosing
15108 SET_FIELD_BITPOS (*fp, 0);
15109 fp->type = get_die_type (die, cu);
15110 fp->artificial = 1;
15111 fp->name = "<<variant>>";
15114 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15117 /* Can the type given by DIE define another type? */
15120 type_can_define_types (const struct die_info *die)
15124 case DW_TAG_typedef:
15125 case DW_TAG_class_type:
15126 case DW_TAG_structure_type:
15127 case DW_TAG_union_type:
15128 case DW_TAG_enumeration_type:
15136 /* Add a type definition defined in the scope of the FIP's class. */
15139 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15140 struct dwarf2_cu *cu)
15142 struct decl_field fp;
15143 memset (&fp, 0, sizeof (fp));
15145 gdb_assert (type_can_define_types (die));
15147 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15148 fp.name = dwarf2_name (die, cu);
15149 fp.type = read_type_die (die, cu);
15151 /* Save accessibility. */
15152 enum dwarf_access_attribute accessibility;
15153 struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15155 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15157 accessibility = dwarf2_default_access_attribute (die, cu);
15158 switch (accessibility)
15160 case DW_ACCESS_public:
15161 /* The assumed value if neither private nor protected. */
15163 case DW_ACCESS_private:
15166 case DW_ACCESS_protected:
15167 fp.is_protected = 1;
15170 complaint (&symfile_complaints,
15171 _("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15174 if (die->tag == DW_TAG_typedef)
15175 fip->typedef_field_list.push_back (fp);
15177 fip->nested_types_list.push_back (fp);
15180 /* Create the vector of fields, and attach it to the type. */
15183 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15184 struct dwarf2_cu *cu)
15186 int nfields = fip->nfields;
15188 /* Record the field count, allocate space for the array of fields,
15189 and create blank accessibility bitfields if necessary. */
15190 TYPE_NFIELDS (type) = nfields;
15191 TYPE_FIELDS (type) = (struct field *)
15192 TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15194 if (fip->non_public_fields && cu->language != language_ada)
15196 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15198 TYPE_FIELD_PRIVATE_BITS (type) =
15199 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15200 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15202 TYPE_FIELD_PROTECTED_BITS (type) =
15203 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15204 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15206 TYPE_FIELD_IGNORE_BITS (type) =
15207 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15208 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15211 /* If the type has baseclasses, allocate and clear a bit vector for
15212 TYPE_FIELD_VIRTUAL_BITS. */
15213 if (!fip->baseclasses.empty () && cu->language != language_ada)
15215 int num_bytes = B_BYTES (fip->baseclasses.size ());
15216 unsigned char *pointer;
15218 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15219 pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15220 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15221 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15222 TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15225 if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15227 struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15229 for (int index = 0; index < nfields; ++index)
15231 struct nextfield &field = fip->fields[index];
15233 if (field.variant.is_discriminant)
15234 di->discriminant_index = index;
15235 else if (field.variant.default_branch)
15236 di->default_index = index;
15238 di->discriminants[index] = field.variant.discriminant_value;
15242 /* Copy the saved-up fields into the field vector. */
15243 for (int i = 0; i < nfields; ++i)
15245 struct nextfield &field
15246 = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15247 : fip->fields[i - fip->baseclasses.size ()]);
15249 TYPE_FIELD (type, i) = field.field;
15250 switch (field.accessibility)
15252 case DW_ACCESS_private:
15253 if (cu->language != language_ada)
15254 SET_TYPE_FIELD_PRIVATE (type, i);
15257 case DW_ACCESS_protected:
15258 if (cu->language != language_ada)
15259 SET_TYPE_FIELD_PROTECTED (type, i);
15262 case DW_ACCESS_public:
15266 /* Unknown accessibility. Complain and treat it as public. */
15268 complaint (&symfile_complaints, _("unsupported accessibility %d"),
15269 field.accessibility);
15273 if (i < fip->baseclasses.size ())
15275 switch (field.virtuality)
15277 case DW_VIRTUALITY_virtual:
15278 case DW_VIRTUALITY_pure_virtual:
15279 if (cu->language == language_ada)
15280 error (_("unexpected virtuality in component of Ada type"));
15281 SET_TYPE_FIELD_VIRTUAL (type, i);
15288 /* Return true if this member function is a constructor, false
15292 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15294 const char *fieldname;
15295 const char *type_name;
15298 if (die->parent == NULL)
15301 if (die->parent->tag != DW_TAG_structure_type
15302 && die->parent->tag != DW_TAG_union_type
15303 && die->parent->tag != DW_TAG_class_type)
15306 fieldname = dwarf2_name (die, cu);
15307 type_name = dwarf2_name (die->parent, cu);
15308 if (fieldname == NULL || type_name == NULL)
15311 len = strlen (fieldname);
15312 return (strncmp (fieldname, type_name, len) == 0
15313 && (type_name[len] == '\0' || type_name[len] == '<'));
15316 /* Add a member function to the proper fieldlist. */
15319 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15320 struct type *type, struct dwarf2_cu *cu)
15322 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15323 struct attribute *attr;
15325 struct fnfieldlist *flp = nullptr;
15326 struct fn_field *fnp;
15327 const char *fieldname;
15328 struct type *this_type;
15329 enum dwarf_access_attribute accessibility;
15331 if (cu->language == language_ada)
15332 error (_("unexpected member function in Ada type"));
15334 /* Get name of member function. */
15335 fieldname = dwarf2_name (die, cu);
15336 if (fieldname == NULL)
15339 /* Look up member function name in fieldlist. */
15340 for (i = 0; i < fip->fnfieldlists.size (); i++)
15342 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15344 flp = &fip->fnfieldlists[i];
15349 /* Create a new fnfieldlist if necessary. */
15350 if (flp == nullptr)
15352 fip->fnfieldlists.emplace_back ();
15353 flp = &fip->fnfieldlists.back ();
15354 flp->name = fieldname;
15355 i = fip->fnfieldlists.size () - 1;
15358 /* Create a new member function field and add it to the vector of
15360 flp->fnfields.emplace_back ();
15361 fnp = &flp->fnfields.back ();
15363 /* Delay processing of the physname until later. */
15364 if (cu->language == language_cplus)
15365 add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15369 const char *physname = dwarf2_physname (fieldname, die, cu);
15370 fnp->physname = physname ? physname : "";
15373 fnp->type = alloc_type (objfile);
15374 this_type = read_type_die (die, cu);
15375 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15377 int nparams = TYPE_NFIELDS (this_type);
15379 /* TYPE is the domain of this method, and THIS_TYPE is the type
15380 of the method itself (TYPE_CODE_METHOD). */
15381 smash_to_method_type (fnp->type, type,
15382 TYPE_TARGET_TYPE (this_type),
15383 TYPE_FIELDS (this_type),
15384 TYPE_NFIELDS (this_type),
15385 TYPE_VARARGS (this_type));
15387 /* Handle static member functions.
15388 Dwarf2 has no clean way to discern C++ static and non-static
15389 member functions. G++ helps GDB by marking the first
15390 parameter for non-static member functions (which is the this
15391 pointer) as artificial. We obtain this information from
15392 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15393 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15394 fnp->voffset = VOFFSET_STATIC;
15397 complaint (&symfile_complaints, _("member function type missing for '%s'"),
15398 dwarf2_full_name (fieldname, die, cu));
15400 /* Get fcontext from DW_AT_containing_type if present. */
15401 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15402 fnp->fcontext = die_containing_type (die, cu);
15404 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15405 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15407 /* Get accessibility. */
15408 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15410 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15412 accessibility = dwarf2_default_access_attribute (die, cu);
15413 switch (accessibility)
15415 case DW_ACCESS_private:
15416 fnp->is_private = 1;
15418 case DW_ACCESS_protected:
15419 fnp->is_protected = 1;
15423 /* Check for artificial methods. */
15424 attr = dwarf2_attr (die, DW_AT_artificial, cu);
15425 if (attr && DW_UNSND (attr) != 0)
15426 fnp->is_artificial = 1;
15428 fnp->is_constructor = dwarf2_is_constructor (die, cu);
15430 /* Get index in virtual function table if it is a virtual member
15431 function. For older versions of GCC, this is an offset in the
15432 appropriate virtual table, as specified by DW_AT_containing_type.
15433 For everyone else, it is an expression to be evaluated relative
15434 to the object address. */
15436 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15439 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15441 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15443 /* Old-style GCC. */
15444 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15446 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15447 || (DW_BLOCK (attr)->size > 1
15448 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15449 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15451 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15452 if ((fnp->voffset % cu->header.addr_size) != 0)
15453 dwarf2_complex_location_expr_complaint ();
15455 fnp->voffset /= cu->header.addr_size;
15459 dwarf2_complex_location_expr_complaint ();
15461 if (!fnp->fcontext)
15463 /* If there is no `this' field and no DW_AT_containing_type,
15464 we cannot actually find a base class context for the
15466 if (TYPE_NFIELDS (this_type) == 0
15467 || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15469 complaint (&symfile_complaints,
15470 _("cannot determine context for virtual member "
15471 "function \"%s\" (offset %s)"),
15472 fieldname, sect_offset_str (die->sect_off));
15477 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15481 else if (attr_form_is_section_offset (attr))
15483 dwarf2_complex_location_expr_complaint ();
15487 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15493 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15494 if (attr && DW_UNSND (attr))
15496 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15497 complaint (&symfile_complaints,
15498 _("Member function \"%s\" (offset %s) is virtual "
15499 "but the vtable offset is not specified"),
15500 fieldname, sect_offset_str (die->sect_off));
15501 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15502 TYPE_CPLUS_DYNAMIC (type) = 1;
15507 /* Create the vector of member function fields, and attach it to the type. */
15510 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15511 struct dwarf2_cu *cu)
15513 if (cu->language == language_ada)
15514 error (_("unexpected member functions in Ada type"));
15516 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15517 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15519 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15521 for (int i = 0; i < fip->fnfieldlists.size (); i++)
15523 struct fnfieldlist &nf = fip->fnfieldlists[i];
15524 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15526 TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15527 TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15528 fn_flp->fn_fields = (struct fn_field *)
15529 TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15531 for (int k = 0; k < nf.fnfields.size (); ++k)
15532 fn_flp->fn_fields[k] = nf.fnfields[k];
15535 TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15538 /* Returns non-zero if NAME is the name of a vtable member in CU's
15539 language, zero otherwise. */
15541 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15543 static const char vptr[] = "_vptr";
15545 /* Look for the C++ form of the vtable. */
15546 if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15552 /* GCC outputs unnamed structures that are really pointers to member
15553 functions, with the ABI-specified layout. If TYPE describes
15554 such a structure, smash it into a member function type.
15556 GCC shouldn't do this; it should just output pointer to member DIEs.
15557 This is GCC PR debug/28767. */
15560 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15562 struct type *pfn_type, *self_type, *new_type;
15564 /* Check for a structure with no name and two children. */
15565 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15568 /* Check for __pfn and __delta members. */
15569 if (TYPE_FIELD_NAME (type, 0) == NULL
15570 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15571 || TYPE_FIELD_NAME (type, 1) == NULL
15572 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15575 /* Find the type of the method. */
15576 pfn_type = TYPE_FIELD_TYPE (type, 0);
15577 if (pfn_type == NULL
15578 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15579 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15582 /* Look for the "this" argument. */
15583 pfn_type = TYPE_TARGET_TYPE (pfn_type);
15584 if (TYPE_NFIELDS (pfn_type) == 0
15585 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15586 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15589 self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15590 new_type = alloc_type (objfile);
15591 smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15592 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15593 TYPE_VARARGS (pfn_type));
15594 smash_to_methodptr_type (type, new_type);
15597 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15598 appropriate error checking and issuing complaints if there is a
15602 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15604 struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15606 if (attr == nullptr)
15609 if (!attr_form_is_constant (attr))
15611 complaint (&symfile_complaints,
15612 _("DW_AT_alignment must have constant form"
15613 " - DIE at %s [in module %s]"),
15614 sect_offset_str (die->sect_off),
15615 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15620 if (attr->form == DW_FORM_sdata)
15622 LONGEST val = DW_SND (attr);
15625 complaint (&symfile_complaints,
15626 _("DW_AT_alignment value must not be negative"
15627 " - DIE at %s [in module %s]"),
15628 sect_offset_str (die->sect_off),
15629 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15635 align = DW_UNSND (attr);
15639 complaint (&symfile_complaints,
15640 _("DW_AT_alignment value must not be zero"
15641 " - DIE at %s [in module %s]"),
15642 sect_offset_str (die->sect_off),
15643 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15646 if ((align & (align - 1)) != 0)
15648 complaint (&symfile_complaints,
15649 _("DW_AT_alignment value must be a power of 2"
15650 " - DIE at %s [in module %s]"),
15651 sect_offset_str (die->sect_off),
15652 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15659 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15660 the alignment for TYPE. */
15663 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15666 if (!set_type_align (type, get_alignment (cu, die)))
15667 complaint (&symfile_complaints,
15668 _("DW_AT_alignment value too large"
15669 " - DIE at %s [in module %s]"),
15670 sect_offset_str (die->sect_off),
15671 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15674 /* Called when we find the DIE that starts a structure or union scope
15675 (definition) to create a type for the structure or union. Fill in
15676 the type's name and general properties; the members will not be
15677 processed until process_structure_scope. A symbol table entry for
15678 the type will also not be done until process_structure_scope (assuming
15679 the type has a name).
15681 NOTE: we need to call these functions regardless of whether or not the
15682 DIE has a DW_AT_name attribute, since it might be an anonymous
15683 structure or union. This gets the type entered into our set of
15684 user defined types. */
15686 static struct type *
15687 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15689 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15691 struct attribute *attr;
15694 /* If the definition of this type lives in .debug_types, read that type.
15695 Don't follow DW_AT_specification though, that will take us back up
15696 the chain and we want to go down. */
15697 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15700 type = get_DW_AT_signature_type (die, attr, cu);
15702 /* The type's CU may not be the same as CU.
15703 Ensure TYPE is recorded with CU in die_type_hash. */
15704 return set_die_type (die, type, cu);
15707 type = alloc_type (objfile);
15708 INIT_CPLUS_SPECIFIC (type);
15710 name = dwarf2_name (die, cu);
15713 if (cu->language == language_cplus
15714 || cu->language == language_d
15715 || cu->language == language_rust)
15717 const char *full_name = dwarf2_full_name (name, die, cu);
15719 /* dwarf2_full_name might have already finished building the DIE's
15720 type. If so, there is no need to continue. */
15721 if (get_die_type (die, cu) != NULL)
15722 return get_die_type (die, cu);
15724 TYPE_TAG_NAME (type) = full_name;
15725 if (die->tag == DW_TAG_structure_type
15726 || die->tag == DW_TAG_class_type)
15727 TYPE_NAME (type) = TYPE_TAG_NAME (type);
15731 /* The name is already allocated along with this objfile, so
15732 we don't need to duplicate it for the type. */
15733 TYPE_TAG_NAME (type) = name;
15734 if (die->tag == DW_TAG_class_type)
15735 TYPE_NAME (type) = TYPE_TAG_NAME (type);
15739 if (die->tag == DW_TAG_structure_type)
15741 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15743 else if (die->tag == DW_TAG_union_type)
15745 TYPE_CODE (type) = TYPE_CODE_UNION;
15747 else if (die->tag == DW_TAG_variant_part)
15749 TYPE_CODE (type) = TYPE_CODE_UNION;
15750 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15754 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15757 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15758 TYPE_DECLARED_CLASS (type) = 1;
15760 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15763 if (attr_form_is_constant (attr))
15764 TYPE_LENGTH (type) = DW_UNSND (attr);
15767 /* For the moment, dynamic type sizes are not supported
15768 by GDB's struct type. The actual size is determined
15769 on-demand when resolving the type of a given object,
15770 so set the type's length to zero for now. Otherwise,
15771 we record an expression as the length, and that expression
15772 could lead to a very large value, which could eventually
15773 lead to us trying to allocate that much memory when creating
15774 a value of that type. */
15775 TYPE_LENGTH (type) = 0;
15780 TYPE_LENGTH (type) = 0;
15783 maybe_set_alignment (cu, die, type);
15785 if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15787 /* ICC<14 does not output the required DW_AT_declaration on
15788 incomplete types, but gives them a size of zero. */
15789 TYPE_STUB (type) = 1;
15792 TYPE_STUB_SUPPORTED (type) = 1;
15794 if (die_is_declaration (die, cu))
15795 TYPE_STUB (type) = 1;
15796 else if (attr == NULL && die->child == NULL
15797 && producer_is_realview (cu->producer))
15798 /* RealView does not output the required DW_AT_declaration
15799 on incomplete types. */
15800 TYPE_STUB (type) = 1;
15802 /* We need to add the type field to the die immediately so we don't
15803 infinitely recurse when dealing with pointers to the structure
15804 type within the structure itself. */
15805 set_die_type (die, type, cu);
15807 /* set_die_type should be already done. */
15808 set_descriptive_type (type, die, cu);
15813 /* A helper for process_structure_scope that handles a single member
15817 handle_struct_member_die (struct die_info *child_die, struct type *type,
15818 struct field_info *fi,
15819 std::vector<struct symbol *> *template_args,
15820 struct dwarf2_cu *cu)
15822 if (child_die->tag == DW_TAG_member
15823 || child_die->tag == DW_TAG_variable
15824 || child_die->tag == DW_TAG_variant_part)
15826 /* NOTE: carlton/2002-11-05: A C++ static data member
15827 should be a DW_TAG_member that is a declaration, but
15828 all versions of G++ as of this writing (so through at
15829 least 3.2.1) incorrectly generate DW_TAG_variable
15830 tags for them instead. */
15831 dwarf2_add_field (fi, child_die, cu);
15833 else if (child_die->tag == DW_TAG_subprogram)
15835 /* Rust doesn't have member functions in the C++ sense.
15836 However, it does emit ordinary functions as children
15837 of a struct DIE. */
15838 if (cu->language == language_rust)
15839 read_func_scope (child_die, cu);
15842 /* C++ member function. */
15843 dwarf2_add_member_fn (fi, child_die, type, cu);
15846 else if (child_die->tag == DW_TAG_inheritance)
15848 /* C++ base class field. */
15849 dwarf2_add_field (fi, child_die, cu);
15851 else if (type_can_define_types (child_die))
15852 dwarf2_add_type_defn (fi, child_die, cu);
15853 else if (child_die->tag == DW_TAG_template_type_param
15854 || child_die->tag == DW_TAG_template_value_param)
15856 struct symbol *arg = new_symbol (child_die, NULL, cu);
15859 template_args->push_back (arg);
15861 else if (child_die->tag == DW_TAG_variant)
15863 /* In a variant we want to get the discriminant and also add a
15864 field for our sole member child. */
15865 struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15867 for (struct die_info *variant_child = child_die->child;
15868 variant_child != NULL;
15869 variant_child = sibling_die (variant_child))
15871 if (variant_child->tag == DW_TAG_member)
15873 handle_struct_member_die (variant_child, type, fi,
15874 template_args, cu);
15875 /* Only handle the one. */
15880 /* We don't handle this but we might as well report it if we see
15882 if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15883 complaint (&symfile_complaints,
15884 _("DW_AT_discr_list is not supported yet"
15885 " - DIE at %s [in module %s]"),
15886 sect_offset_str (child_die->sect_off),
15887 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15889 /* The first field was just added, so we can stash the
15890 discriminant there. */
15891 gdb_assert (!fi->fields.empty ());
15893 fi->fields.back ().variant.default_branch = true;
15895 fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15899 /* Finish creating a structure or union type, including filling in
15900 its members and creating a symbol for it. */
15903 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
15905 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15906 struct die_info *child_die;
15909 type = get_die_type (die, cu);
15911 type = read_structure_type (die, cu);
15913 /* When reading a DW_TAG_variant_part, we need to notice when we
15914 read the discriminant member, so we can record it later in the
15915 discriminant_info. */
15916 bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
15917 sect_offset discr_offset;
15919 if (is_variant_part)
15921 struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
15924 /* Maybe it's a univariant form, an extension we support.
15925 In this case arrange not to check the offset. */
15926 is_variant_part = false;
15928 else if (attr_form_is_ref (discr))
15930 struct dwarf2_cu *target_cu = cu;
15931 struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
15933 discr_offset = target_die->sect_off;
15937 complaint (&symfile_complaints,
15938 _("DW_AT_discr does not have DIE reference form"
15939 " - DIE at %s [in module %s]"),
15940 sect_offset_str (die->sect_off),
15941 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15942 is_variant_part = false;
15946 if (die->child != NULL && ! die_is_declaration (die, cu))
15948 struct field_info fi;
15949 std::vector<struct symbol *> template_args;
15951 child_die = die->child;
15953 while (child_die && child_die->tag)
15955 handle_struct_member_die (child_die, type, &fi, &template_args, cu);
15957 if (is_variant_part && discr_offset == child_die->sect_off)
15958 fi.fields.back ().variant.is_discriminant = true;
15960 child_die = sibling_die (child_die);
15963 /* Attach template arguments to type. */
15964 if (!template_args.empty ())
15966 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15967 TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
15968 TYPE_TEMPLATE_ARGUMENTS (type)
15969 = XOBNEWVEC (&objfile->objfile_obstack,
15971 TYPE_N_TEMPLATE_ARGUMENTS (type));
15972 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
15973 template_args.data (),
15974 (TYPE_N_TEMPLATE_ARGUMENTS (type)
15975 * sizeof (struct symbol *)));
15978 /* Attach fields and member functions to the type. */
15980 dwarf2_attach_fields_to_type (&fi, type, cu);
15981 if (!fi.fnfieldlists.empty ())
15983 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
15985 /* Get the type which refers to the base class (possibly this
15986 class itself) which contains the vtable pointer for the current
15987 class from the DW_AT_containing_type attribute. This use of
15988 DW_AT_containing_type is a GNU extension. */
15990 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15992 struct type *t = die_containing_type (die, cu);
15994 set_type_vptr_basetype (type, t);
15999 /* Our own class provides vtbl ptr. */
16000 for (i = TYPE_NFIELDS (t) - 1;
16001 i >= TYPE_N_BASECLASSES (t);
16004 const char *fieldname = TYPE_FIELD_NAME (t, i);
16006 if (is_vtable_name (fieldname, cu))
16008 set_type_vptr_fieldno (type, i);
16013 /* Complain if virtual function table field not found. */
16014 if (i < TYPE_N_BASECLASSES (t))
16015 complaint (&symfile_complaints,
16016 _("virtual function table pointer "
16017 "not found when defining class '%s'"),
16018 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
16023 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16026 else if (cu->producer
16027 && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16029 /* The IBM XLC compiler does not provide direct indication
16030 of the containing type, but the vtable pointer is
16031 always named __vfp. */
16035 for (i = TYPE_NFIELDS (type) - 1;
16036 i >= TYPE_N_BASECLASSES (type);
16039 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16041 set_type_vptr_fieldno (type, i);
16042 set_type_vptr_basetype (type, type);
16049 /* Copy fi.typedef_field_list linked list elements content into the
16050 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16051 if (!fi.typedef_field_list.empty ())
16053 int count = fi.typedef_field_list.size ();
16055 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16056 TYPE_TYPEDEF_FIELD_ARRAY (type)
16057 = ((struct decl_field *)
16059 sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16060 TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16062 for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16063 TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16066 /* Copy fi.nested_types_list linked list elements content into the
16067 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16068 if (!fi.nested_types_list.empty () && cu->language != language_ada)
16070 int count = fi.nested_types_list.size ();
16072 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16073 TYPE_NESTED_TYPES_ARRAY (type)
16074 = ((struct decl_field *)
16075 TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16076 TYPE_NESTED_TYPES_COUNT (type) = count;
16078 for (int i = 0; i < fi.nested_types_list.size (); ++i)
16079 TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16083 quirk_gcc_member_function_pointer (type, objfile);
16084 if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16085 cu->rust_unions.push_back (type);
16087 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16088 snapshots) has been known to create a die giving a declaration
16089 for a class that has, as a child, a die giving a definition for a
16090 nested class. So we have to process our children even if the
16091 current die is a declaration. Normally, of course, a declaration
16092 won't have any children at all. */
16094 child_die = die->child;
16096 while (child_die != NULL && child_die->tag)
16098 if (child_die->tag == DW_TAG_member
16099 || child_die->tag == DW_TAG_variable
16100 || child_die->tag == DW_TAG_inheritance
16101 || child_die->tag == DW_TAG_template_value_param
16102 || child_die->tag == DW_TAG_template_type_param)
16107 process_die (child_die, cu);
16109 child_die = sibling_die (child_die);
16112 /* Do not consider external references. According to the DWARF standard,
16113 these DIEs are identified by the fact that they have no byte_size
16114 attribute, and a declaration attribute. */
16115 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16116 || !die_is_declaration (die, cu))
16117 new_symbol (die, type, cu);
16120 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16121 update TYPE using some information only available in DIE's children. */
16124 update_enumeration_type_from_children (struct die_info *die,
16126 struct dwarf2_cu *cu)
16128 struct die_info *child_die;
16129 int unsigned_enum = 1;
16133 auto_obstack obstack;
16135 for (child_die = die->child;
16136 child_die != NULL && child_die->tag;
16137 child_die = sibling_die (child_die))
16139 struct attribute *attr;
16141 const gdb_byte *bytes;
16142 struct dwarf2_locexpr_baton *baton;
16145 if (child_die->tag != DW_TAG_enumerator)
16148 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16152 name = dwarf2_name (child_die, cu);
16154 name = "<anonymous enumerator>";
16156 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16157 &value, &bytes, &baton);
16163 else if ((mask & value) != 0)
16168 /* If we already know that the enum type is neither unsigned, nor
16169 a flag type, no need to look at the rest of the enumerates. */
16170 if (!unsigned_enum && !flag_enum)
16175 TYPE_UNSIGNED (type) = 1;
16177 TYPE_FLAG_ENUM (type) = 1;
16180 /* Given a DW_AT_enumeration_type die, set its type. We do not
16181 complete the type's fields yet, or create any symbols. */
16183 static struct type *
16184 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16186 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16188 struct attribute *attr;
16191 /* If the definition of this type lives in .debug_types, read that type.
16192 Don't follow DW_AT_specification though, that will take us back up
16193 the chain and we want to go down. */
16194 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16197 type = get_DW_AT_signature_type (die, attr, cu);
16199 /* The type's CU may not be the same as CU.
16200 Ensure TYPE is recorded with CU in die_type_hash. */
16201 return set_die_type (die, type, cu);
16204 type = alloc_type (objfile);
16206 TYPE_CODE (type) = TYPE_CODE_ENUM;
16207 name = dwarf2_full_name (NULL, die, cu);
16209 TYPE_TAG_NAME (type) = name;
16211 attr = dwarf2_attr (die, DW_AT_type, cu);
16214 struct type *underlying_type = die_type (die, cu);
16216 TYPE_TARGET_TYPE (type) = underlying_type;
16219 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16222 TYPE_LENGTH (type) = DW_UNSND (attr);
16226 TYPE_LENGTH (type) = 0;
16229 maybe_set_alignment (cu, die, type);
16231 /* The enumeration DIE can be incomplete. In Ada, any type can be
16232 declared as private in the package spec, and then defined only
16233 inside the package body. Such types are known as Taft Amendment
16234 Types. When another package uses such a type, an incomplete DIE
16235 may be generated by the compiler. */
16236 if (die_is_declaration (die, cu))
16237 TYPE_STUB (type) = 1;
16239 /* Finish the creation of this type by using the enum's children.
16240 We must call this even when the underlying type has been provided
16241 so that we can determine if we're looking at a "flag" enum. */
16242 update_enumeration_type_from_children (die, type, cu);
16244 /* If this type has an underlying type that is not a stub, then we
16245 may use its attributes. We always use the "unsigned" attribute
16246 in this situation, because ordinarily we guess whether the type
16247 is unsigned -- but the guess can be wrong and the underlying type
16248 can tell us the reality. However, we defer to a local size
16249 attribute if one exists, because this lets the compiler override
16250 the underlying type if needed. */
16251 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16253 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16254 if (TYPE_LENGTH (type) == 0)
16255 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16256 if (TYPE_RAW_ALIGN (type) == 0
16257 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16258 set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16261 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16263 return set_die_type (die, type, cu);
16266 /* Given a pointer to a die which begins an enumeration, process all
16267 the dies that define the members of the enumeration, and create the
16268 symbol for the enumeration type.
16270 NOTE: We reverse the order of the element list. */
16273 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16275 struct type *this_type;
16277 this_type = get_die_type (die, cu);
16278 if (this_type == NULL)
16279 this_type = read_enumeration_type (die, cu);
16281 if (die->child != NULL)
16283 struct die_info *child_die;
16284 struct symbol *sym;
16285 struct field *fields = NULL;
16286 int num_fields = 0;
16289 child_die = die->child;
16290 while (child_die && child_die->tag)
16292 if (child_die->tag != DW_TAG_enumerator)
16294 process_die (child_die, cu);
16298 name = dwarf2_name (child_die, cu);
16301 sym = new_symbol (child_die, this_type, cu);
16303 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16305 fields = (struct field *)
16307 (num_fields + DW_FIELD_ALLOC_CHUNK)
16308 * sizeof (struct field));
16311 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16312 FIELD_TYPE (fields[num_fields]) = NULL;
16313 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16314 FIELD_BITSIZE (fields[num_fields]) = 0;
16320 child_die = sibling_die (child_die);
16325 TYPE_NFIELDS (this_type) = num_fields;
16326 TYPE_FIELDS (this_type) = (struct field *)
16327 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16328 memcpy (TYPE_FIELDS (this_type), fields,
16329 sizeof (struct field) * num_fields);
16334 /* If we are reading an enum from a .debug_types unit, and the enum
16335 is a declaration, and the enum is not the signatured type in the
16336 unit, then we do not want to add a symbol for it. Adding a
16337 symbol would in some cases obscure the true definition of the
16338 enum, giving users an incomplete type when the definition is
16339 actually available. Note that we do not want to do this for all
16340 enums which are just declarations, because C++0x allows forward
16341 enum declarations. */
16342 if (cu->per_cu->is_debug_types
16343 && die_is_declaration (die, cu))
16345 struct signatured_type *sig_type;
16347 sig_type = (struct signatured_type *) cu->per_cu;
16348 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16349 if (sig_type->type_offset_in_section != die->sect_off)
16353 new_symbol (die, this_type, cu);
16356 /* Extract all information from a DW_TAG_array_type DIE and put it in
16357 the DIE's type field. For now, this only handles one dimensional
16360 static struct type *
16361 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16363 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16364 struct die_info *child_die;
16366 struct type *element_type, *range_type, *index_type;
16367 struct attribute *attr;
16369 struct dynamic_prop *byte_stride_prop = NULL;
16370 unsigned int bit_stride = 0;
16372 element_type = die_type (die, cu);
16374 /* The die_type call above may have already set the type for this DIE. */
16375 type = get_die_type (die, cu);
16379 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16385 = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16386 stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16389 complaint (&symfile_complaints,
16390 _("unable to read array DW_AT_byte_stride "
16391 " - DIE at %s [in module %s]"),
16392 sect_offset_str (die->sect_off),
16393 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16394 /* Ignore this attribute. We will likely not be able to print
16395 arrays of this type correctly, but there is little we can do
16396 to help if we cannot read the attribute's value. */
16397 byte_stride_prop = NULL;
16401 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16403 bit_stride = DW_UNSND (attr);
16405 /* Irix 6.2 native cc creates array types without children for
16406 arrays with unspecified length. */
16407 if (die->child == NULL)
16409 index_type = objfile_type (objfile)->builtin_int;
16410 range_type = create_static_range_type (NULL, index_type, 0, -1);
16411 type = create_array_type_with_stride (NULL, element_type, range_type,
16412 byte_stride_prop, bit_stride);
16413 return set_die_type (die, type, cu);
16416 std::vector<struct type *> range_types;
16417 child_die = die->child;
16418 while (child_die && child_die->tag)
16420 if (child_die->tag == DW_TAG_subrange_type)
16422 struct type *child_type = read_type_die (child_die, cu);
16424 if (child_type != NULL)
16426 /* The range type was succesfully read. Save it for the
16427 array type creation. */
16428 range_types.push_back (child_type);
16431 child_die = sibling_die (child_die);
16434 /* Dwarf2 dimensions are output from left to right, create the
16435 necessary array types in backwards order. */
16437 type = element_type;
16439 if (read_array_order (die, cu) == DW_ORD_col_major)
16443 while (i < range_types.size ())
16444 type = create_array_type_with_stride (NULL, type, range_types[i++],
16445 byte_stride_prop, bit_stride);
16449 size_t ndim = range_types.size ();
16451 type = create_array_type_with_stride (NULL, type, range_types[ndim],
16452 byte_stride_prop, bit_stride);
16455 /* Understand Dwarf2 support for vector types (like they occur on
16456 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16457 array type. This is not part of the Dwarf2/3 standard yet, but a
16458 custom vendor extension. The main difference between a regular
16459 array and the vector variant is that vectors are passed by value
16461 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16463 make_vector_type (type);
16465 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16466 implementation may choose to implement triple vectors using this
16468 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16471 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16472 TYPE_LENGTH (type) = DW_UNSND (attr);
16474 complaint (&symfile_complaints,
16475 _("DW_AT_byte_size for array type smaller "
16476 "than the total size of elements"));
16479 name = dwarf2_name (die, cu);
16481 TYPE_NAME (type) = name;
16483 maybe_set_alignment (cu, die, type);
16485 /* Install the type in the die. */
16486 set_die_type (die, type, cu);
16488 /* set_die_type should be already done. */
16489 set_descriptive_type (type, die, cu);
16494 static enum dwarf_array_dim_ordering
16495 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16497 struct attribute *attr;
16499 attr = dwarf2_attr (die, DW_AT_ordering, cu);
16502 return (enum dwarf_array_dim_ordering) DW_SND (attr);
16504 /* GNU F77 is a special case, as at 08/2004 array type info is the
16505 opposite order to the dwarf2 specification, but data is still
16506 laid out as per normal fortran.
16508 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16509 version checking. */
16511 if (cu->language == language_fortran
16512 && cu->producer && strstr (cu->producer, "GNU F77"))
16514 return DW_ORD_row_major;
16517 switch (cu->language_defn->la_array_ordering)
16519 case array_column_major:
16520 return DW_ORD_col_major;
16521 case array_row_major:
16523 return DW_ORD_row_major;
16527 /* Extract all information from a DW_TAG_set_type DIE and put it in
16528 the DIE's type field. */
16530 static struct type *
16531 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16533 struct type *domain_type, *set_type;
16534 struct attribute *attr;
16536 domain_type = die_type (die, cu);
16538 /* The die_type call above may have already set the type for this DIE. */
16539 set_type = get_die_type (die, cu);
16543 set_type = create_set_type (NULL, domain_type);
16545 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16547 TYPE_LENGTH (set_type) = DW_UNSND (attr);
16549 maybe_set_alignment (cu, die, set_type);
16551 return set_die_type (die, set_type, cu);
16554 /* A helper for read_common_block that creates a locexpr baton.
16555 SYM is the symbol which we are marking as computed.
16556 COMMON_DIE is the DIE for the common block.
16557 COMMON_LOC is the location expression attribute for the common
16559 MEMBER_LOC is the location expression attribute for the particular
16560 member of the common block that we are processing.
16561 CU is the CU from which the above come. */
16564 mark_common_block_symbol_computed (struct symbol *sym,
16565 struct die_info *common_die,
16566 struct attribute *common_loc,
16567 struct attribute *member_loc,
16568 struct dwarf2_cu *cu)
16570 struct dwarf2_per_objfile *dwarf2_per_objfile
16571 = cu->per_cu->dwarf2_per_objfile;
16572 struct objfile *objfile = dwarf2_per_objfile->objfile;
16573 struct dwarf2_locexpr_baton *baton;
16575 unsigned int cu_off;
16576 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16577 LONGEST offset = 0;
16579 gdb_assert (common_loc && member_loc);
16580 gdb_assert (attr_form_is_block (common_loc));
16581 gdb_assert (attr_form_is_block (member_loc)
16582 || attr_form_is_constant (member_loc));
16584 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16585 baton->per_cu = cu->per_cu;
16586 gdb_assert (baton->per_cu);
16588 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16590 if (attr_form_is_constant (member_loc))
16592 offset = dwarf2_get_attr_constant_value (member_loc, 0);
16593 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16596 baton->size += DW_BLOCK (member_loc)->size;
16598 ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16601 *ptr++ = DW_OP_call4;
16602 cu_off = common_die->sect_off - cu->per_cu->sect_off;
16603 store_unsigned_integer (ptr, 4, byte_order, cu_off);
16606 if (attr_form_is_constant (member_loc))
16608 *ptr++ = DW_OP_addr;
16609 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16610 ptr += cu->header.addr_size;
16614 /* We have to copy the data here, because DW_OP_call4 will only
16615 use a DW_AT_location attribute. */
16616 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16617 ptr += DW_BLOCK (member_loc)->size;
16620 *ptr++ = DW_OP_plus;
16621 gdb_assert (ptr - baton->data == baton->size);
16623 SYMBOL_LOCATION_BATON (sym) = baton;
16624 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16627 /* Create appropriate locally-scoped variables for all the
16628 DW_TAG_common_block entries. Also create a struct common_block
16629 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16630 is used to sepate the common blocks name namespace from regular
16634 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16636 struct attribute *attr;
16638 attr = dwarf2_attr (die, DW_AT_location, cu);
16641 /* Support the .debug_loc offsets. */
16642 if (attr_form_is_block (attr))
16646 else if (attr_form_is_section_offset (attr))
16648 dwarf2_complex_location_expr_complaint ();
16653 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16654 "common block member");
16659 if (die->child != NULL)
16661 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16662 struct die_info *child_die;
16663 size_t n_entries = 0, size;
16664 struct common_block *common_block;
16665 struct symbol *sym;
16667 for (child_die = die->child;
16668 child_die && child_die->tag;
16669 child_die = sibling_die (child_die))
16672 size = (sizeof (struct common_block)
16673 + (n_entries - 1) * sizeof (struct symbol *));
16675 = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16677 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16678 common_block->n_entries = 0;
16680 for (child_die = die->child;
16681 child_die && child_die->tag;
16682 child_die = sibling_die (child_die))
16684 /* Create the symbol in the DW_TAG_common_block block in the current
16686 sym = new_symbol (child_die, NULL, cu);
16689 struct attribute *member_loc;
16691 common_block->contents[common_block->n_entries++] = sym;
16693 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16697 /* GDB has handled this for a long time, but it is
16698 not specified by DWARF. It seems to have been
16699 emitted by gfortran at least as recently as:
16700 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16701 complaint (&symfile_complaints,
16702 _("Variable in common block has "
16703 "DW_AT_data_member_location "
16704 "- DIE at %s [in module %s]"),
16705 sect_offset_str (child_die->sect_off),
16706 objfile_name (objfile));
16708 if (attr_form_is_section_offset (member_loc))
16709 dwarf2_complex_location_expr_complaint ();
16710 else if (attr_form_is_constant (member_loc)
16711 || attr_form_is_block (member_loc))
16714 mark_common_block_symbol_computed (sym, die, attr,
16718 dwarf2_complex_location_expr_complaint ();
16723 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16724 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16728 /* Create a type for a C++ namespace. */
16730 static struct type *
16731 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16733 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16734 const char *previous_prefix, *name;
16738 /* For extensions, reuse the type of the original namespace. */
16739 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16741 struct die_info *ext_die;
16742 struct dwarf2_cu *ext_cu = cu;
16744 ext_die = dwarf2_extension (die, &ext_cu);
16745 type = read_type_die (ext_die, ext_cu);
16747 /* EXT_CU may not be the same as CU.
16748 Ensure TYPE is recorded with CU in die_type_hash. */
16749 return set_die_type (die, type, cu);
16752 name = namespace_name (die, &is_anonymous, cu);
16754 /* Now build the name of the current namespace. */
16756 previous_prefix = determine_prefix (die, cu);
16757 if (previous_prefix[0] != '\0')
16758 name = typename_concat (&objfile->objfile_obstack,
16759 previous_prefix, name, 0, cu);
16761 /* Create the type. */
16762 type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16763 TYPE_TAG_NAME (type) = TYPE_NAME (type);
16765 return set_die_type (die, type, cu);
16768 /* Read a namespace scope. */
16771 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16773 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16776 /* Add a symbol associated to this if we haven't seen the namespace
16777 before. Also, add a using directive if it's an anonymous
16780 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16784 type = read_type_die (die, cu);
16785 new_symbol (die, type, cu);
16787 namespace_name (die, &is_anonymous, cu);
16790 const char *previous_prefix = determine_prefix (die, cu);
16792 std::vector<const char *> excludes;
16793 add_using_directive (using_directives (cu->language),
16794 previous_prefix, TYPE_NAME (type), NULL,
16795 NULL, excludes, 0, &objfile->objfile_obstack);
16799 if (die->child != NULL)
16801 struct die_info *child_die = die->child;
16803 while (child_die && child_die->tag)
16805 process_die (child_die, cu);
16806 child_die = sibling_die (child_die);
16811 /* Read a Fortran module as type. This DIE can be only a declaration used for
16812 imported module. Still we need that type as local Fortran "use ... only"
16813 declaration imports depend on the created type in determine_prefix. */
16815 static struct type *
16816 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16818 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16819 const char *module_name;
16822 module_name = dwarf2_name (die, cu);
16824 complaint (&symfile_complaints,
16825 _("DW_TAG_module has no name, offset %s"),
16826 sect_offset_str (die->sect_off));
16827 type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16829 /* determine_prefix uses TYPE_TAG_NAME. */
16830 TYPE_TAG_NAME (type) = TYPE_NAME (type);
16832 return set_die_type (die, type, cu);
16835 /* Read a Fortran module. */
16838 read_module (struct die_info *die, struct dwarf2_cu *cu)
16840 struct die_info *child_die = die->child;
16843 type = read_type_die (die, cu);
16844 new_symbol (die, type, cu);
16846 while (child_die && child_die->tag)
16848 process_die (child_die, cu);
16849 child_die = sibling_die (child_die);
16853 /* Return the name of the namespace represented by DIE. Set
16854 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16857 static const char *
16858 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16860 struct die_info *current_die;
16861 const char *name = NULL;
16863 /* Loop through the extensions until we find a name. */
16865 for (current_die = die;
16866 current_die != NULL;
16867 current_die = dwarf2_extension (die, &cu))
16869 /* We don't use dwarf2_name here so that we can detect the absence
16870 of a name -> anonymous namespace. */
16871 name = dwarf2_string_attr (die, DW_AT_name, cu);
16877 /* Is it an anonymous namespace? */
16879 *is_anonymous = (name == NULL);
16881 name = CP_ANONYMOUS_NAMESPACE_STR;
16886 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16887 the user defined type vector. */
16889 static struct type *
16890 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16892 struct gdbarch *gdbarch
16893 = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16894 struct comp_unit_head *cu_header = &cu->header;
16896 struct attribute *attr_byte_size;
16897 struct attribute *attr_address_class;
16898 int byte_size, addr_class;
16899 struct type *target_type;
16901 target_type = die_type (die, cu);
16903 /* The die_type call above may have already set the type for this DIE. */
16904 type = get_die_type (die, cu);
16908 type = lookup_pointer_type (target_type);
16910 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
16911 if (attr_byte_size)
16912 byte_size = DW_UNSND (attr_byte_size);
16914 byte_size = cu_header->addr_size;
16916 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
16917 if (attr_address_class)
16918 addr_class = DW_UNSND (attr_address_class);
16920 addr_class = DW_ADDR_none;
16922 ULONGEST alignment = get_alignment (cu, die);
16924 /* If the pointer size, alignment, or address class is different
16925 than the default, create a type variant marked as such and set
16926 the length accordingly. */
16927 if (TYPE_LENGTH (type) != byte_size
16928 || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
16929 && alignment != TYPE_RAW_ALIGN (type))
16930 || addr_class != DW_ADDR_none)
16932 if (gdbarch_address_class_type_flags_p (gdbarch))
16936 type_flags = gdbarch_address_class_type_flags
16937 (gdbarch, byte_size, addr_class);
16938 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
16940 type = make_type_with_address_space (type, type_flags);
16942 else if (TYPE_LENGTH (type) != byte_size)
16944 complaint (&symfile_complaints,
16945 _("invalid pointer size %d"), byte_size);
16947 else if (TYPE_RAW_ALIGN (type) != alignment)
16949 complaint (&symfile_complaints,
16950 _("Invalid DW_AT_alignment"
16951 " - DIE at %s [in module %s]"),
16952 sect_offset_str (die->sect_off),
16953 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16957 /* Should we also complain about unhandled address classes? */
16961 TYPE_LENGTH (type) = byte_size;
16962 set_type_align (type, alignment);
16963 return set_die_type (die, type, cu);
16966 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
16967 the user defined type vector. */
16969 static struct type *
16970 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
16973 struct type *to_type;
16974 struct type *domain;
16976 to_type = die_type (die, cu);
16977 domain = die_containing_type (die, cu);
16979 /* The calls above may have already set the type for this DIE. */
16980 type = get_die_type (die, cu);
16984 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
16985 type = lookup_methodptr_type (to_type);
16986 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
16988 struct type *new_type
16989 = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
16991 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
16992 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
16993 TYPE_VARARGS (to_type));
16994 type = lookup_methodptr_type (new_type);
16997 type = lookup_memberptr_type (to_type, domain);
16999 return set_die_type (die, type, cu);
17002 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17003 the user defined type vector. */
17005 static struct type *
17006 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17007 enum type_code refcode)
17009 struct comp_unit_head *cu_header = &cu->header;
17010 struct type *type, *target_type;
17011 struct attribute *attr;
17013 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17015 target_type = die_type (die, cu);
17017 /* The die_type call above may have already set the type for this DIE. */
17018 type = get_die_type (die, cu);
17022 type = lookup_reference_type (target_type, refcode);
17023 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17026 TYPE_LENGTH (type) = DW_UNSND (attr);
17030 TYPE_LENGTH (type) = cu_header->addr_size;
17032 maybe_set_alignment (cu, die, type);
17033 return set_die_type (die, type, cu);
17036 /* Add the given cv-qualifiers to the element type of the array. GCC
17037 outputs DWARF type qualifiers that apply to an array, not the
17038 element type. But GDB relies on the array element type to carry
17039 the cv-qualifiers. This mimics section 6.7.3 of the C99
17042 static struct type *
17043 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17044 struct type *base_type, int cnst, int voltl)
17046 struct type *el_type, *inner_array;
17048 base_type = copy_type (base_type);
17049 inner_array = base_type;
17051 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17053 TYPE_TARGET_TYPE (inner_array) =
17054 copy_type (TYPE_TARGET_TYPE (inner_array));
17055 inner_array = TYPE_TARGET_TYPE (inner_array);
17058 el_type = TYPE_TARGET_TYPE (inner_array);
17059 cnst |= TYPE_CONST (el_type);
17060 voltl |= TYPE_VOLATILE (el_type);
17061 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17063 return set_die_type (die, base_type, cu);
17066 static struct type *
17067 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17069 struct type *base_type, *cv_type;
17071 base_type = die_type (die, cu);
17073 /* The die_type call above may have already set the type for this DIE. */
17074 cv_type = get_die_type (die, cu);
17078 /* In case the const qualifier is applied to an array type, the element type
17079 is so qualified, not the array type (section 6.7.3 of C99). */
17080 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17081 return add_array_cv_type (die, cu, base_type, 1, 0);
17083 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17084 return set_die_type (die, cv_type, cu);
17087 static struct type *
17088 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17090 struct type *base_type, *cv_type;
17092 base_type = die_type (die, cu);
17094 /* The die_type call above may have already set the type for this DIE. */
17095 cv_type = get_die_type (die, cu);
17099 /* In case the volatile qualifier is applied to an array type, the
17100 element type is so qualified, not the array type (section 6.7.3
17102 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17103 return add_array_cv_type (die, cu, base_type, 0, 1);
17105 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17106 return set_die_type (die, cv_type, cu);
17109 /* Handle DW_TAG_restrict_type. */
17111 static struct type *
17112 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17114 struct type *base_type, *cv_type;
17116 base_type = die_type (die, cu);
17118 /* The die_type call above may have already set the type for this DIE. */
17119 cv_type = get_die_type (die, cu);
17123 cv_type = make_restrict_type (base_type);
17124 return set_die_type (die, cv_type, cu);
17127 /* Handle DW_TAG_atomic_type. */
17129 static struct type *
17130 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17132 struct type *base_type, *cv_type;
17134 base_type = die_type (die, cu);
17136 /* The die_type call above may have already set the type for this DIE. */
17137 cv_type = get_die_type (die, cu);
17141 cv_type = make_atomic_type (base_type);
17142 return set_die_type (die, cv_type, cu);
17145 /* Extract all information from a DW_TAG_string_type DIE and add to
17146 the user defined type vector. It isn't really a user defined type,
17147 but it behaves like one, with other DIE's using an AT_user_def_type
17148 attribute to reference it. */
17150 static struct type *
17151 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17153 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17154 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17155 struct type *type, *range_type, *index_type, *char_type;
17156 struct attribute *attr;
17157 unsigned int length;
17159 attr = dwarf2_attr (die, DW_AT_string_length, cu);
17162 length = DW_UNSND (attr);
17166 /* Check for the DW_AT_byte_size attribute. */
17167 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17170 length = DW_UNSND (attr);
17178 index_type = objfile_type (objfile)->builtin_int;
17179 range_type = create_static_range_type (NULL, index_type, 1, length);
17180 char_type = language_string_char_type (cu->language_defn, gdbarch);
17181 type = create_string_type (NULL, char_type, range_type);
17183 return set_die_type (die, type, cu);
17186 /* Assuming that DIE corresponds to a function, returns nonzero
17187 if the function is prototyped. */
17190 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17192 struct attribute *attr;
17194 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17195 if (attr && (DW_UNSND (attr) != 0))
17198 /* The DWARF standard implies that the DW_AT_prototyped attribute
17199 is only meaninful for C, but the concept also extends to other
17200 languages that allow unprototyped functions (Eg: Objective C).
17201 For all other languages, assume that functions are always
17203 if (cu->language != language_c
17204 && cu->language != language_objc
17205 && cu->language != language_opencl)
17208 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17209 prototyped and unprototyped functions; default to prototyped,
17210 since that is more common in modern code (and RealView warns
17211 about unprototyped functions). */
17212 if (producer_is_realview (cu->producer))
17218 /* Handle DIES due to C code like:
17222 int (*funcp)(int a, long l);
17226 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17228 static struct type *
17229 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17231 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17232 struct type *type; /* Type that this function returns. */
17233 struct type *ftype; /* Function that returns above type. */
17234 struct attribute *attr;
17236 type = die_type (die, cu);
17238 /* The die_type call above may have already set the type for this DIE. */
17239 ftype = get_die_type (die, cu);
17243 ftype = lookup_function_type (type);
17245 if (prototyped_function_p (die, cu))
17246 TYPE_PROTOTYPED (ftype) = 1;
17248 /* Store the calling convention in the type if it's available in
17249 the subroutine die. Otherwise set the calling convention to
17250 the default value DW_CC_normal. */
17251 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17253 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17254 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17255 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17257 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17259 /* Record whether the function returns normally to its caller or not
17260 if the DWARF producer set that information. */
17261 attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17262 if (attr && (DW_UNSND (attr) != 0))
17263 TYPE_NO_RETURN (ftype) = 1;
17265 /* We need to add the subroutine type to the die immediately so
17266 we don't infinitely recurse when dealing with parameters
17267 declared as the same subroutine type. */
17268 set_die_type (die, ftype, cu);
17270 if (die->child != NULL)
17272 struct type *void_type = objfile_type (objfile)->builtin_void;
17273 struct die_info *child_die;
17274 int nparams, iparams;
17276 /* Count the number of parameters.
17277 FIXME: GDB currently ignores vararg functions, but knows about
17278 vararg member functions. */
17280 child_die = die->child;
17281 while (child_die && child_die->tag)
17283 if (child_die->tag == DW_TAG_formal_parameter)
17285 else if (child_die->tag == DW_TAG_unspecified_parameters)
17286 TYPE_VARARGS (ftype) = 1;
17287 child_die = sibling_die (child_die);
17290 /* Allocate storage for parameters and fill them in. */
17291 TYPE_NFIELDS (ftype) = nparams;
17292 TYPE_FIELDS (ftype) = (struct field *)
17293 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17295 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17296 even if we error out during the parameters reading below. */
17297 for (iparams = 0; iparams < nparams; iparams++)
17298 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17301 child_die = die->child;
17302 while (child_die && child_die->tag)
17304 if (child_die->tag == DW_TAG_formal_parameter)
17306 struct type *arg_type;
17308 /* DWARF version 2 has no clean way to discern C++
17309 static and non-static member functions. G++ helps
17310 GDB by marking the first parameter for non-static
17311 member functions (which is the this pointer) as
17312 artificial. We pass this information to
17313 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17315 DWARF version 3 added DW_AT_object_pointer, which GCC
17316 4.5 does not yet generate. */
17317 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17319 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17321 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17322 arg_type = die_type (child_die, cu);
17324 /* RealView does not mark THIS as const, which the testsuite
17325 expects. GCC marks THIS as const in method definitions,
17326 but not in the class specifications (GCC PR 43053). */
17327 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17328 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17331 struct dwarf2_cu *arg_cu = cu;
17332 const char *name = dwarf2_name (child_die, cu);
17334 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17337 /* If the compiler emits this, use it. */
17338 if (follow_die_ref (die, attr, &arg_cu) == child_die)
17341 else if (name && strcmp (name, "this") == 0)
17342 /* Function definitions will have the argument names. */
17344 else if (name == NULL && iparams == 0)
17345 /* Declarations may not have the names, so like
17346 elsewhere in GDB, assume an artificial first
17347 argument is "this". */
17351 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17355 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17358 child_die = sibling_die (child_die);
17365 static struct type *
17366 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17368 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17369 const char *name = NULL;
17370 struct type *this_type, *target_type;
17372 name = dwarf2_full_name (NULL, die, cu);
17373 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17374 TYPE_TARGET_STUB (this_type) = 1;
17375 set_die_type (die, this_type, cu);
17376 target_type = die_type (die, cu);
17377 if (target_type != this_type)
17378 TYPE_TARGET_TYPE (this_type) = target_type;
17381 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17382 spec and cause infinite loops in GDB. */
17383 complaint (&symfile_complaints,
17384 _("Self-referential DW_TAG_typedef "
17385 "- DIE at %s [in module %s]"),
17386 sect_offset_str (die->sect_off), objfile_name (objfile));
17387 TYPE_TARGET_TYPE (this_type) = NULL;
17392 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17393 (which may be different from NAME) to the architecture back-end to allow
17394 it to guess the correct format if necessary. */
17396 static struct type *
17397 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17398 const char *name_hint)
17400 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17401 const struct floatformat **format;
17404 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17406 type = init_float_type (objfile, bits, name, format);
17408 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17413 /* Find a representation of a given base type and install
17414 it in the TYPE field of the die. */
17416 static struct type *
17417 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17419 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17421 struct attribute *attr;
17422 int encoding = 0, bits = 0;
17425 attr = dwarf2_attr (die, DW_AT_encoding, cu);
17428 encoding = DW_UNSND (attr);
17430 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17433 bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17435 name = dwarf2_name (die, cu);
17438 complaint (&symfile_complaints,
17439 _("DW_AT_name missing from DW_TAG_base_type"));
17444 case DW_ATE_address:
17445 /* Turn DW_ATE_address into a void * pointer. */
17446 type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17447 type = init_pointer_type (objfile, bits, name, type);
17449 case DW_ATE_boolean:
17450 type = init_boolean_type (objfile, bits, 1, name);
17452 case DW_ATE_complex_float:
17453 type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17454 type = init_complex_type (objfile, name, type);
17456 case DW_ATE_decimal_float:
17457 type = init_decfloat_type (objfile, bits, name);
17460 type = dwarf2_init_float_type (objfile, bits, name, name);
17462 case DW_ATE_signed:
17463 type = init_integer_type (objfile, bits, 0, name);
17465 case DW_ATE_unsigned:
17466 if (cu->language == language_fortran
17468 && startswith (name, "character("))
17469 type = init_character_type (objfile, bits, 1, name);
17471 type = init_integer_type (objfile, bits, 1, name);
17473 case DW_ATE_signed_char:
17474 if (cu->language == language_ada || cu->language == language_m2
17475 || cu->language == language_pascal
17476 || cu->language == language_fortran)
17477 type = init_character_type (objfile, bits, 0, name);
17479 type = init_integer_type (objfile, bits, 0, name);
17481 case DW_ATE_unsigned_char:
17482 if (cu->language == language_ada || cu->language == language_m2
17483 || cu->language == language_pascal
17484 || cu->language == language_fortran
17485 || cu->language == language_rust)
17486 type = init_character_type (objfile, bits, 1, name);
17488 type = init_integer_type (objfile, bits, 1, name);
17492 gdbarch *arch = get_objfile_arch (objfile);
17495 type = builtin_type (arch)->builtin_char16;
17496 else if (bits == 32)
17497 type = builtin_type (arch)->builtin_char32;
17500 complaint (&symfile_complaints,
17501 _("unsupported DW_ATE_UTF bit size: '%d'"),
17503 type = init_integer_type (objfile, bits, 1, name);
17505 return set_die_type (die, type, cu);
17510 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
17511 dwarf_type_encoding_name (encoding));
17512 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17516 if (name && strcmp (name, "char") == 0)
17517 TYPE_NOSIGN (type) = 1;
17519 maybe_set_alignment (cu, die, type);
17521 return set_die_type (die, type, cu);
17524 /* Parse dwarf attribute if it's a block, reference or constant and put the
17525 resulting value of the attribute into struct bound_prop.
17526 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17529 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17530 struct dwarf2_cu *cu, struct dynamic_prop *prop)
17532 struct dwarf2_property_baton *baton;
17533 struct obstack *obstack
17534 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17536 if (attr == NULL || prop == NULL)
17539 if (attr_form_is_block (attr))
17541 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17542 baton->referenced_type = NULL;
17543 baton->locexpr.per_cu = cu->per_cu;
17544 baton->locexpr.size = DW_BLOCK (attr)->size;
17545 baton->locexpr.data = DW_BLOCK (attr)->data;
17546 prop->data.baton = baton;
17547 prop->kind = PROP_LOCEXPR;
17548 gdb_assert (prop->data.baton != NULL);
17550 else if (attr_form_is_ref (attr))
17552 struct dwarf2_cu *target_cu = cu;
17553 struct die_info *target_die;
17554 struct attribute *target_attr;
17556 target_die = follow_die_ref (die, attr, &target_cu);
17557 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17558 if (target_attr == NULL)
17559 target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17561 if (target_attr == NULL)
17564 switch (target_attr->name)
17566 case DW_AT_location:
17567 if (attr_form_is_section_offset (target_attr))
17569 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17570 baton->referenced_type = die_type (target_die, target_cu);
17571 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17572 prop->data.baton = baton;
17573 prop->kind = PROP_LOCLIST;
17574 gdb_assert (prop->data.baton != NULL);
17576 else if (attr_form_is_block (target_attr))
17578 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17579 baton->referenced_type = die_type (target_die, target_cu);
17580 baton->locexpr.per_cu = cu->per_cu;
17581 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17582 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17583 prop->data.baton = baton;
17584 prop->kind = PROP_LOCEXPR;
17585 gdb_assert (prop->data.baton != NULL);
17589 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17590 "dynamic property");
17594 case DW_AT_data_member_location:
17598 if (!handle_data_member_location (target_die, target_cu,
17602 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17603 baton->referenced_type = read_type_die (target_die->parent,
17605 baton->offset_info.offset = offset;
17606 baton->offset_info.type = die_type (target_die, target_cu);
17607 prop->data.baton = baton;
17608 prop->kind = PROP_ADDR_OFFSET;
17613 else if (attr_form_is_constant (attr))
17615 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17616 prop->kind = PROP_CONST;
17620 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17621 dwarf2_name (die, cu));
17628 /* Read the given DW_AT_subrange DIE. */
17630 static struct type *
17631 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17633 struct type *base_type, *orig_base_type;
17634 struct type *range_type;
17635 struct attribute *attr;
17636 struct dynamic_prop low, high;
17637 int low_default_is_valid;
17638 int high_bound_is_count = 0;
17640 LONGEST negative_mask;
17642 orig_base_type = die_type (die, cu);
17643 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17644 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17645 creating the range type, but we use the result of check_typedef
17646 when examining properties of the type. */
17647 base_type = check_typedef (orig_base_type);
17649 /* The die_type call above may have already set the type for this DIE. */
17650 range_type = get_die_type (die, cu);
17654 low.kind = PROP_CONST;
17655 high.kind = PROP_CONST;
17656 high.data.const_val = 0;
17658 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17659 omitting DW_AT_lower_bound. */
17660 switch (cu->language)
17663 case language_cplus:
17664 low.data.const_val = 0;
17665 low_default_is_valid = 1;
17667 case language_fortran:
17668 low.data.const_val = 1;
17669 low_default_is_valid = 1;
17672 case language_objc:
17673 case language_rust:
17674 low.data.const_val = 0;
17675 low_default_is_valid = (cu->header.version >= 4);
17679 case language_pascal:
17680 low.data.const_val = 1;
17681 low_default_is_valid = (cu->header.version >= 4);
17684 low.data.const_val = 0;
17685 low_default_is_valid = 0;
17689 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17691 attr_to_dynamic_prop (attr, die, cu, &low);
17692 else if (!low_default_is_valid)
17693 complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
17694 "- DIE at %s [in module %s]"),
17695 sect_offset_str (die->sect_off),
17696 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17698 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
17699 if (!attr_to_dynamic_prop (attr, die, cu, &high))
17701 attr = dwarf2_attr (die, DW_AT_count, cu);
17702 if (attr_to_dynamic_prop (attr, die, cu, &high))
17704 /* If bounds are constant do the final calculation here. */
17705 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17706 high.data.const_val = low.data.const_val + high.data.const_val - 1;
17708 high_bound_is_count = 1;
17712 /* Dwarf-2 specifications explicitly allows to create subrange types
17713 without specifying a base type.
17714 In that case, the base type must be set to the type of
17715 the lower bound, upper bound or count, in that order, if any of these
17716 three attributes references an object that has a type.
17717 If no base type is found, the Dwarf-2 specifications say that
17718 a signed integer type of size equal to the size of an address should
17720 For the following C code: `extern char gdb_int [];'
17721 GCC produces an empty range DIE.
17722 FIXME: muller/2010-05-28: Possible references to object for low bound,
17723 high bound or count are not yet handled by this code. */
17724 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17726 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17727 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17728 int addr_size = gdbarch_addr_bit (gdbarch) /8;
17729 struct type *int_type = objfile_type (objfile)->builtin_int;
17731 /* Test "int", "long int", and "long long int" objfile types,
17732 and select the first one having a size above or equal to the
17733 architecture address size. */
17734 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17735 base_type = int_type;
17738 int_type = objfile_type (objfile)->builtin_long;
17739 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17740 base_type = int_type;
17743 int_type = objfile_type (objfile)->builtin_long_long;
17744 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17745 base_type = int_type;
17750 /* Normally, the DWARF producers are expected to use a signed
17751 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17752 But this is unfortunately not always the case, as witnessed
17753 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17754 is used instead. To work around that ambiguity, we treat
17755 the bounds as signed, and thus sign-extend their values, when
17756 the base type is signed. */
17758 -((LONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17759 if (low.kind == PROP_CONST
17760 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17761 low.data.const_val |= negative_mask;
17762 if (high.kind == PROP_CONST
17763 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17764 high.data.const_val |= negative_mask;
17766 range_type = create_range_type (NULL, orig_base_type, &low, &high);
17768 if (high_bound_is_count)
17769 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17771 /* Ada expects an empty array on no boundary attributes. */
17772 if (attr == NULL && cu->language != language_ada)
17773 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17775 name = dwarf2_name (die, cu);
17777 TYPE_NAME (range_type) = name;
17779 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17781 TYPE_LENGTH (range_type) = DW_UNSND (attr);
17783 maybe_set_alignment (cu, die, range_type);
17785 set_die_type (die, range_type, cu);
17787 /* set_die_type should be already done. */
17788 set_descriptive_type (range_type, die, cu);
17793 static struct type *
17794 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17798 type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17800 TYPE_NAME (type) = dwarf2_name (die, cu);
17802 /* In Ada, an unspecified type is typically used when the description
17803 of the type is defered to a different unit. When encountering
17804 such a type, we treat it as a stub, and try to resolve it later on,
17806 if (cu->language == language_ada)
17807 TYPE_STUB (type) = 1;
17809 return set_die_type (die, type, cu);
17812 /* Read a single die and all its descendents. Set the die's sibling
17813 field to NULL; set other fields in the die correctly, and set all
17814 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17815 location of the info_ptr after reading all of those dies. PARENT
17816 is the parent of the die in question. */
17818 static struct die_info *
17819 read_die_and_children (const struct die_reader_specs *reader,
17820 const gdb_byte *info_ptr,
17821 const gdb_byte **new_info_ptr,
17822 struct die_info *parent)
17824 struct die_info *die;
17825 const gdb_byte *cur_ptr;
17828 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17831 *new_info_ptr = cur_ptr;
17834 store_in_ref_table (die, reader->cu);
17837 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17841 *new_info_ptr = cur_ptr;
17844 die->sibling = NULL;
17845 die->parent = parent;
17849 /* Read a die, all of its descendents, and all of its siblings; set
17850 all of the fields of all of the dies correctly. Arguments are as
17851 in read_die_and_children. */
17853 static struct die_info *
17854 read_die_and_siblings_1 (const struct die_reader_specs *reader,
17855 const gdb_byte *info_ptr,
17856 const gdb_byte **new_info_ptr,
17857 struct die_info *parent)
17859 struct die_info *first_die, *last_sibling;
17860 const gdb_byte *cur_ptr;
17862 cur_ptr = info_ptr;
17863 first_die = last_sibling = NULL;
17867 struct die_info *die
17868 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
17872 *new_info_ptr = cur_ptr;
17879 last_sibling->sibling = die;
17881 last_sibling = die;
17885 /* Read a die, all of its descendents, and all of its siblings; set
17886 all of the fields of all of the dies correctly. Arguments are as
17887 in read_die_and_children.
17888 This the main entry point for reading a DIE and all its children. */
17890 static struct die_info *
17891 read_die_and_siblings (const struct die_reader_specs *reader,
17892 const gdb_byte *info_ptr,
17893 const gdb_byte **new_info_ptr,
17894 struct die_info *parent)
17896 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
17897 new_info_ptr, parent);
17899 if (dwarf_die_debug)
17901 fprintf_unfiltered (gdb_stdlog,
17902 "Read die from %s@0x%x of %s:\n",
17903 get_section_name (reader->die_section),
17904 (unsigned) (info_ptr - reader->die_section->buffer),
17905 bfd_get_filename (reader->abfd));
17906 dump_die (die, dwarf_die_debug);
17912 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
17914 The caller is responsible for filling in the extra attributes
17915 and updating (*DIEP)->num_attrs.
17916 Set DIEP to point to a newly allocated die with its information,
17917 except for its child, sibling, and parent fields.
17918 Set HAS_CHILDREN to tell whether the die has children or not. */
17920 static const gdb_byte *
17921 read_full_die_1 (const struct die_reader_specs *reader,
17922 struct die_info **diep, const gdb_byte *info_ptr,
17923 int *has_children, int num_extra_attrs)
17925 unsigned int abbrev_number, bytes_read, i;
17926 struct abbrev_info *abbrev;
17927 struct die_info *die;
17928 struct dwarf2_cu *cu = reader->cu;
17929 bfd *abfd = reader->abfd;
17931 sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
17932 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
17933 info_ptr += bytes_read;
17934 if (!abbrev_number)
17941 abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
17943 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
17945 bfd_get_filename (abfd));
17947 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
17948 die->sect_off = sect_off;
17949 die->tag = abbrev->tag;
17950 die->abbrev = abbrev_number;
17952 /* Make the result usable.
17953 The caller needs to update num_attrs after adding the extra
17955 die->num_attrs = abbrev->num_attrs;
17957 for (i = 0; i < abbrev->num_attrs; ++i)
17958 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
17962 *has_children = abbrev->has_children;
17966 /* Read a die and all its attributes.
17967 Set DIEP to point to a newly allocated die with its information,
17968 except for its child, sibling, and parent fields.
17969 Set HAS_CHILDREN to tell whether the die has children or not. */
17971 static const gdb_byte *
17972 read_full_die (const struct die_reader_specs *reader,
17973 struct die_info **diep, const gdb_byte *info_ptr,
17976 const gdb_byte *result;
17978 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
17980 if (dwarf_die_debug)
17982 fprintf_unfiltered (gdb_stdlog,
17983 "Read die from %s@0x%x of %s:\n",
17984 get_section_name (reader->die_section),
17985 (unsigned) (info_ptr - reader->die_section->buffer),
17986 bfd_get_filename (reader->abfd));
17987 dump_die (*diep, dwarf_die_debug);
17993 /* Abbreviation tables.
17995 In DWARF version 2, the description of the debugging information is
17996 stored in a separate .debug_abbrev section. Before we read any
17997 dies from a section we read in all abbreviations and install them
17998 in a hash table. */
18000 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18002 struct abbrev_info *
18003 abbrev_table::alloc_abbrev ()
18005 struct abbrev_info *abbrev;
18007 abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18008 memset (abbrev, 0, sizeof (struct abbrev_info));
18013 /* Add an abbreviation to the table. */
18016 abbrev_table::add_abbrev (unsigned int abbrev_number,
18017 struct abbrev_info *abbrev)
18019 unsigned int hash_number;
18021 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18022 abbrev->next = m_abbrevs[hash_number];
18023 m_abbrevs[hash_number] = abbrev;
18026 /* Look up an abbrev in the table.
18027 Returns NULL if the abbrev is not found. */
18029 struct abbrev_info *
18030 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18032 unsigned int hash_number;
18033 struct abbrev_info *abbrev;
18035 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18036 abbrev = m_abbrevs[hash_number];
18040 if (abbrev->number == abbrev_number)
18042 abbrev = abbrev->next;
18047 /* Read in an abbrev table. */
18049 static abbrev_table_up
18050 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18051 struct dwarf2_section_info *section,
18052 sect_offset sect_off)
18054 struct objfile *objfile = dwarf2_per_objfile->objfile;
18055 bfd *abfd = get_section_bfd_owner (section);
18056 const gdb_byte *abbrev_ptr;
18057 struct abbrev_info *cur_abbrev;
18058 unsigned int abbrev_number, bytes_read, abbrev_name;
18059 unsigned int abbrev_form;
18060 struct attr_abbrev *cur_attrs;
18061 unsigned int allocated_attrs;
18063 abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18065 dwarf2_read_section (objfile, section);
18066 abbrev_ptr = section->buffer + to_underlying (sect_off);
18067 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18068 abbrev_ptr += bytes_read;
18070 allocated_attrs = ATTR_ALLOC_CHUNK;
18071 cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18073 /* Loop until we reach an abbrev number of 0. */
18074 while (abbrev_number)
18076 cur_abbrev = abbrev_table->alloc_abbrev ();
18078 /* read in abbrev header */
18079 cur_abbrev->number = abbrev_number;
18081 = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18082 abbrev_ptr += bytes_read;
18083 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18086 /* now read in declarations */
18089 LONGEST implicit_const;
18091 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18092 abbrev_ptr += bytes_read;
18093 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18094 abbrev_ptr += bytes_read;
18095 if (abbrev_form == DW_FORM_implicit_const)
18097 implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18099 abbrev_ptr += bytes_read;
18103 /* Initialize it due to a false compiler warning. */
18104 implicit_const = -1;
18107 if (abbrev_name == 0)
18110 if (cur_abbrev->num_attrs == allocated_attrs)
18112 allocated_attrs += ATTR_ALLOC_CHUNK;
18114 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18117 cur_attrs[cur_abbrev->num_attrs].name
18118 = (enum dwarf_attribute) abbrev_name;
18119 cur_attrs[cur_abbrev->num_attrs].form
18120 = (enum dwarf_form) abbrev_form;
18121 cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18122 ++cur_abbrev->num_attrs;
18125 cur_abbrev->attrs =
18126 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18127 cur_abbrev->num_attrs);
18128 memcpy (cur_abbrev->attrs, cur_attrs,
18129 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18131 abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18133 /* Get next abbreviation.
18134 Under Irix6 the abbreviations for a compilation unit are not
18135 always properly terminated with an abbrev number of 0.
18136 Exit loop if we encounter an abbreviation which we have
18137 already read (which means we are about to read the abbreviations
18138 for the next compile unit) or if the end of the abbreviation
18139 table is reached. */
18140 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18142 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18143 abbrev_ptr += bytes_read;
18144 if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18149 return abbrev_table;
18152 /* Returns nonzero if TAG represents a type that we might generate a partial
18156 is_type_tag_for_partial (int tag)
18161 /* Some types that would be reasonable to generate partial symbols for,
18162 that we don't at present. */
18163 case DW_TAG_array_type:
18164 case DW_TAG_file_type:
18165 case DW_TAG_ptr_to_member_type:
18166 case DW_TAG_set_type:
18167 case DW_TAG_string_type:
18168 case DW_TAG_subroutine_type:
18170 case DW_TAG_base_type:
18171 case DW_TAG_class_type:
18172 case DW_TAG_interface_type:
18173 case DW_TAG_enumeration_type:
18174 case DW_TAG_structure_type:
18175 case DW_TAG_subrange_type:
18176 case DW_TAG_typedef:
18177 case DW_TAG_union_type:
18184 /* Load all DIEs that are interesting for partial symbols into memory. */
18186 static struct partial_die_info *
18187 load_partial_dies (const struct die_reader_specs *reader,
18188 const gdb_byte *info_ptr, int building_psymtab)
18190 struct dwarf2_cu *cu = reader->cu;
18191 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18192 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18193 unsigned int bytes_read;
18194 unsigned int load_all = 0;
18195 int nesting_level = 1;
18200 gdb_assert (cu->per_cu != NULL);
18201 if (cu->per_cu->load_all_dies)
18205 = htab_create_alloc_ex (cu->header.length / 12,
18209 &cu->comp_unit_obstack,
18210 hashtab_obstack_allocate,
18211 dummy_obstack_deallocate);
18215 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18217 /* A NULL abbrev means the end of a series of children. */
18218 if (abbrev == NULL)
18220 if (--nesting_level == 0)
18223 info_ptr += bytes_read;
18224 last_die = parent_die;
18225 parent_die = parent_die->die_parent;
18229 /* Check for template arguments. We never save these; if
18230 they're seen, we just mark the parent, and go on our way. */
18231 if (parent_die != NULL
18232 && cu->language == language_cplus
18233 && (abbrev->tag == DW_TAG_template_type_param
18234 || abbrev->tag == DW_TAG_template_value_param))
18236 parent_die->has_template_arguments = 1;
18240 /* We don't need a partial DIE for the template argument. */
18241 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18246 /* We only recurse into c++ subprograms looking for template arguments.
18247 Skip their other children. */
18249 && cu->language == language_cplus
18250 && parent_die != NULL
18251 && parent_die->tag == DW_TAG_subprogram)
18253 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18257 /* Check whether this DIE is interesting enough to save. Normally
18258 we would not be interested in members here, but there may be
18259 later variables referencing them via DW_AT_specification (for
18260 static members). */
18262 && !is_type_tag_for_partial (abbrev->tag)
18263 && abbrev->tag != DW_TAG_constant
18264 && abbrev->tag != DW_TAG_enumerator
18265 && abbrev->tag != DW_TAG_subprogram
18266 && abbrev->tag != DW_TAG_inlined_subroutine
18267 && abbrev->tag != DW_TAG_lexical_block
18268 && abbrev->tag != DW_TAG_variable
18269 && abbrev->tag != DW_TAG_namespace
18270 && abbrev->tag != DW_TAG_module
18271 && abbrev->tag != DW_TAG_member
18272 && abbrev->tag != DW_TAG_imported_unit
18273 && abbrev->tag != DW_TAG_imported_declaration)
18275 /* Otherwise we skip to the next sibling, if any. */
18276 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18280 struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18283 info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18285 /* This two-pass algorithm for processing partial symbols has a
18286 high cost in cache pressure. Thus, handle some simple cases
18287 here which cover the majority of C partial symbols. DIEs
18288 which neither have specification tags in them, nor could have
18289 specification tags elsewhere pointing at them, can simply be
18290 processed and discarded.
18292 This segment is also optional; scan_partial_symbols and
18293 add_partial_symbol will handle these DIEs if we chain
18294 them in normally. When compilers which do not emit large
18295 quantities of duplicate debug information are more common,
18296 this code can probably be removed. */
18298 /* Any complete simple types at the top level (pretty much all
18299 of them, for a language without namespaces), can be processed
18301 if (parent_die == NULL
18302 && pdi.has_specification == 0
18303 && pdi.is_declaration == 0
18304 && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18305 || pdi.tag == DW_TAG_base_type
18306 || pdi.tag == DW_TAG_subrange_type))
18308 if (building_psymtab && pdi.name != NULL)
18309 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18310 VAR_DOMAIN, LOC_TYPEDEF,
18311 &objfile->static_psymbols,
18312 0, cu->language, objfile);
18313 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18317 /* The exception for DW_TAG_typedef with has_children above is
18318 a workaround of GCC PR debug/47510. In the case of this complaint
18319 type_name_no_tag_or_error will error on such types later.
18321 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18322 it could not find the child DIEs referenced later, this is checked
18323 above. In correct DWARF DW_TAG_typedef should have no children. */
18325 if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18326 complaint (&symfile_complaints,
18327 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18328 "- DIE at %s [in module %s]"),
18329 sect_offset_str (pdi.sect_off), objfile_name (objfile));
18331 /* If we're at the second level, and we're an enumerator, and
18332 our parent has no specification (meaning possibly lives in a
18333 namespace elsewhere), then we can add the partial symbol now
18334 instead of queueing it. */
18335 if (pdi.tag == DW_TAG_enumerator
18336 && parent_die != NULL
18337 && parent_die->die_parent == NULL
18338 && parent_die->tag == DW_TAG_enumeration_type
18339 && parent_die->has_specification == 0)
18341 if (pdi.name == NULL)
18342 complaint (&symfile_complaints,
18343 _("malformed enumerator DIE ignored"));
18344 else if (building_psymtab)
18345 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18346 VAR_DOMAIN, LOC_CONST,
18347 cu->language == language_cplus
18348 ? &objfile->global_psymbols
18349 : &objfile->static_psymbols,
18350 0, cu->language, objfile);
18352 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18356 struct partial_die_info *part_die
18357 = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18359 /* We'll save this DIE so link it in. */
18360 part_die->die_parent = parent_die;
18361 part_die->die_sibling = NULL;
18362 part_die->die_child = NULL;
18364 if (last_die && last_die == parent_die)
18365 last_die->die_child = part_die;
18367 last_die->die_sibling = part_die;
18369 last_die = part_die;
18371 if (first_die == NULL)
18372 first_die = part_die;
18374 /* Maybe add the DIE to the hash table. Not all DIEs that we
18375 find interesting need to be in the hash table, because we
18376 also have the parent/sibling/child chains; only those that we
18377 might refer to by offset later during partial symbol reading.
18379 For now this means things that might have be the target of a
18380 DW_AT_specification, DW_AT_abstract_origin, or
18381 DW_AT_extension. DW_AT_extension will refer only to
18382 namespaces; DW_AT_abstract_origin refers to functions (and
18383 many things under the function DIE, but we do not recurse
18384 into function DIEs during partial symbol reading) and
18385 possibly variables as well; DW_AT_specification refers to
18386 declarations. Declarations ought to have the DW_AT_declaration
18387 flag. It happens that GCC forgets to put it in sometimes, but
18388 only for functions, not for types.
18390 Adding more things than necessary to the hash table is harmless
18391 except for the performance cost. Adding too few will result in
18392 wasted time in find_partial_die, when we reread the compilation
18393 unit with load_all_dies set. */
18396 || abbrev->tag == DW_TAG_constant
18397 || abbrev->tag == DW_TAG_subprogram
18398 || abbrev->tag == DW_TAG_variable
18399 || abbrev->tag == DW_TAG_namespace
18400 || part_die->is_declaration)
18404 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18405 to_underlying (part_die->sect_off),
18410 /* For some DIEs we want to follow their children (if any). For C
18411 we have no reason to follow the children of structures; for other
18412 languages we have to, so that we can get at method physnames
18413 to infer fully qualified class names, for DW_AT_specification,
18414 and for C++ template arguments. For C++, we also look one level
18415 inside functions to find template arguments (if the name of the
18416 function does not already contain the template arguments).
18418 For Ada, we need to scan the children of subprograms and lexical
18419 blocks as well because Ada allows the definition of nested
18420 entities that could be interesting for the debugger, such as
18421 nested subprograms for instance. */
18422 if (last_die->has_children
18424 || last_die->tag == DW_TAG_namespace
18425 || last_die->tag == DW_TAG_module
18426 || last_die->tag == DW_TAG_enumeration_type
18427 || (cu->language == language_cplus
18428 && last_die->tag == DW_TAG_subprogram
18429 && (last_die->name == NULL
18430 || strchr (last_die->name, '<') == NULL))
18431 || (cu->language != language_c
18432 && (last_die->tag == DW_TAG_class_type
18433 || last_die->tag == DW_TAG_interface_type
18434 || last_die->tag == DW_TAG_structure_type
18435 || last_die->tag == DW_TAG_union_type))
18436 || (cu->language == language_ada
18437 && (last_die->tag == DW_TAG_subprogram
18438 || last_die->tag == DW_TAG_lexical_block))))
18441 parent_die = last_die;
18445 /* Otherwise we skip to the next sibling, if any. */
18446 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18448 /* Back to the top, do it again. */
18452 partial_die_info::partial_die_info (sect_offset sect_off_,
18453 struct abbrev_info *abbrev)
18454 : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18458 /* Read a minimal amount of information into the minimal die structure.
18459 INFO_PTR should point just after the initial uleb128 of a DIE. */
18462 partial_die_info::read (const struct die_reader_specs *reader,
18463 const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18465 struct dwarf2_cu *cu = reader->cu;
18466 struct dwarf2_per_objfile *dwarf2_per_objfile
18467 = cu->per_cu->dwarf2_per_objfile;
18469 int has_low_pc_attr = 0;
18470 int has_high_pc_attr = 0;
18471 int high_pc_relative = 0;
18473 for (i = 0; i < abbrev.num_attrs; ++i)
18475 struct attribute attr;
18477 info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18479 /* Store the data if it is of an attribute we want to keep in a
18480 partial symbol table. */
18486 case DW_TAG_compile_unit:
18487 case DW_TAG_partial_unit:
18488 case DW_TAG_type_unit:
18489 /* Compilation units have a DW_AT_name that is a filename, not
18490 a source language identifier. */
18491 case DW_TAG_enumeration_type:
18492 case DW_TAG_enumerator:
18493 /* These tags always have simple identifiers already; no need
18494 to canonicalize them. */
18495 name = DW_STRING (&attr);
18499 struct objfile *objfile = dwarf2_per_objfile->objfile;
18502 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18503 &objfile->per_bfd->storage_obstack);
18508 case DW_AT_linkage_name:
18509 case DW_AT_MIPS_linkage_name:
18510 /* Note that both forms of linkage name might appear. We
18511 assume they will be the same, and we only store the last
18513 if (cu->language == language_ada)
18514 name = DW_STRING (&attr);
18515 linkage_name = DW_STRING (&attr);
18518 has_low_pc_attr = 1;
18519 lowpc = attr_value_as_address (&attr);
18521 case DW_AT_high_pc:
18522 has_high_pc_attr = 1;
18523 highpc = attr_value_as_address (&attr);
18524 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18525 high_pc_relative = 1;
18527 case DW_AT_location:
18528 /* Support the .debug_loc offsets. */
18529 if (attr_form_is_block (&attr))
18531 d.locdesc = DW_BLOCK (&attr);
18533 else if (attr_form_is_section_offset (&attr))
18535 dwarf2_complex_location_expr_complaint ();
18539 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18540 "partial symbol information");
18543 case DW_AT_external:
18544 is_external = DW_UNSND (&attr);
18546 case DW_AT_declaration:
18547 is_declaration = DW_UNSND (&attr);
18552 case DW_AT_abstract_origin:
18553 case DW_AT_specification:
18554 case DW_AT_extension:
18555 has_specification = 1;
18556 spec_offset = dwarf2_get_ref_die_offset (&attr);
18557 spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18558 || cu->per_cu->is_dwz);
18560 case DW_AT_sibling:
18561 /* Ignore absolute siblings, they might point outside of
18562 the current compile unit. */
18563 if (attr.form == DW_FORM_ref_addr)
18564 complaint (&symfile_complaints,
18565 _("ignoring absolute DW_AT_sibling"));
18568 const gdb_byte *buffer = reader->buffer;
18569 sect_offset off = dwarf2_get_ref_die_offset (&attr);
18570 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18572 if (sibling_ptr < info_ptr)
18573 complaint (&symfile_complaints,
18574 _("DW_AT_sibling points backwards"));
18575 else if (sibling_ptr > reader->buffer_end)
18576 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18578 sibling = sibling_ptr;
18581 case DW_AT_byte_size:
18584 case DW_AT_const_value:
18585 has_const_value = 1;
18587 case DW_AT_calling_convention:
18588 /* DWARF doesn't provide a way to identify a program's source-level
18589 entry point. DW_AT_calling_convention attributes are only meant
18590 to describe functions' calling conventions.
18592 However, because it's a necessary piece of information in
18593 Fortran, and before DWARF 4 DW_CC_program was the only
18594 piece of debugging information whose definition refers to
18595 a 'main program' at all, several compilers marked Fortran
18596 main programs with DW_CC_program --- even when those
18597 functions use the standard calling conventions.
18599 Although DWARF now specifies a way to provide this
18600 information, we support this practice for backward
18602 if (DW_UNSND (&attr) == DW_CC_program
18603 && cu->language == language_fortran)
18604 main_subprogram = 1;
18607 if (DW_UNSND (&attr) == DW_INL_inlined
18608 || DW_UNSND (&attr) == DW_INL_declared_inlined)
18609 may_be_inlined = 1;
18613 if (tag == DW_TAG_imported_unit)
18615 d.sect_off = dwarf2_get_ref_die_offset (&attr);
18616 is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18617 || cu->per_cu->is_dwz);
18621 case DW_AT_main_subprogram:
18622 main_subprogram = DW_UNSND (&attr);
18630 if (high_pc_relative)
18633 if (has_low_pc_attr && has_high_pc_attr)
18635 /* When using the GNU linker, .gnu.linkonce. sections are used to
18636 eliminate duplicate copies of functions and vtables and such.
18637 The linker will arbitrarily choose one and discard the others.
18638 The AT_*_pc values for such functions refer to local labels in
18639 these sections. If the section from that file was discarded, the
18640 labels are not in the output, so the relocs get a value of 0.
18641 If this is a discarded function, mark the pc bounds as invalid,
18642 so that GDB will ignore it. */
18643 if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18645 struct objfile *objfile = dwarf2_per_objfile->objfile;
18646 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18648 complaint (&symfile_complaints,
18649 _("DW_AT_low_pc %s is zero "
18650 "for DIE at %s [in module %s]"),
18651 paddress (gdbarch, lowpc),
18652 sect_offset_str (sect_off),
18653 objfile_name (objfile));
18655 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18656 else if (lowpc >= highpc)
18658 struct objfile *objfile = dwarf2_per_objfile->objfile;
18659 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18661 complaint (&symfile_complaints,
18662 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18663 "for DIE at %s [in module %s]"),
18664 paddress (gdbarch, lowpc),
18665 paddress (gdbarch, highpc),
18666 sect_offset_str (sect_off),
18667 objfile_name (objfile));
18676 /* Find a cached partial DIE at OFFSET in CU. */
18678 struct partial_die_info *
18679 dwarf2_cu::find_partial_die (sect_offset sect_off)
18681 struct partial_die_info *lookup_die = NULL;
18682 struct partial_die_info part_die (sect_off);
18684 lookup_die = ((struct partial_die_info *)
18685 htab_find_with_hash (partial_dies, &part_die,
18686 to_underlying (sect_off)));
18691 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18692 except in the case of .debug_types DIEs which do not reference
18693 outside their CU (they do however referencing other types via
18694 DW_FORM_ref_sig8). */
18696 static struct partial_die_info *
18697 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18699 struct dwarf2_per_objfile *dwarf2_per_objfile
18700 = cu->per_cu->dwarf2_per_objfile;
18701 struct objfile *objfile = dwarf2_per_objfile->objfile;
18702 struct dwarf2_per_cu_data *per_cu = NULL;
18703 struct partial_die_info *pd = NULL;
18705 if (offset_in_dwz == cu->per_cu->is_dwz
18706 && offset_in_cu_p (&cu->header, sect_off))
18708 pd = cu->find_partial_die (sect_off);
18711 /* We missed recording what we needed.
18712 Load all dies and try again. */
18713 per_cu = cu->per_cu;
18717 /* TUs don't reference other CUs/TUs (except via type signatures). */
18718 if (cu->per_cu->is_debug_types)
18720 error (_("Dwarf Error: Type Unit at offset %s contains"
18721 " external reference to offset %s [in module %s].\n"),
18722 sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18723 bfd_get_filename (objfile->obfd));
18725 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18726 dwarf2_per_objfile);
18728 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18729 load_partial_comp_unit (per_cu);
18731 per_cu->cu->last_used = 0;
18732 pd = per_cu->cu->find_partial_die (sect_off);
18735 /* If we didn't find it, and not all dies have been loaded,
18736 load them all and try again. */
18738 if (pd == NULL && per_cu->load_all_dies == 0)
18740 per_cu->load_all_dies = 1;
18742 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18743 THIS_CU->cu may already be in use. So we can't just free it and
18744 replace its DIEs with the ones we read in. Instead, we leave those
18745 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18746 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18748 load_partial_comp_unit (per_cu);
18750 pd = per_cu->cu->find_partial_die (sect_off);
18754 internal_error (__FILE__, __LINE__,
18755 _("could not find partial DIE %s "
18756 "in cache [from module %s]\n"),
18757 sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18761 /* See if we can figure out if the class lives in a namespace. We do
18762 this by looking for a member function; its demangled name will
18763 contain namespace info, if there is any. */
18766 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18767 struct dwarf2_cu *cu)
18769 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18770 what template types look like, because the demangler
18771 frequently doesn't give the same name as the debug info. We
18772 could fix this by only using the demangled name to get the
18773 prefix (but see comment in read_structure_type). */
18775 struct partial_die_info *real_pdi;
18776 struct partial_die_info *child_pdi;
18778 /* If this DIE (this DIE's specification, if any) has a parent, then
18779 we should not do this. We'll prepend the parent's fully qualified
18780 name when we create the partial symbol. */
18782 real_pdi = struct_pdi;
18783 while (real_pdi->has_specification)
18784 real_pdi = find_partial_die (real_pdi->spec_offset,
18785 real_pdi->spec_is_dwz, cu);
18787 if (real_pdi->die_parent != NULL)
18790 for (child_pdi = struct_pdi->die_child;
18792 child_pdi = child_pdi->die_sibling)
18794 if (child_pdi->tag == DW_TAG_subprogram
18795 && child_pdi->linkage_name != NULL)
18797 char *actual_class_name
18798 = language_class_name_from_physname (cu->language_defn,
18799 child_pdi->linkage_name);
18800 if (actual_class_name != NULL)
18802 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18805 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18807 strlen (actual_class_name)));
18808 xfree (actual_class_name);
18816 partial_die_info::fixup (struct dwarf2_cu *cu)
18818 /* Once we've fixed up a die, there's no point in doing so again.
18819 This also avoids a memory leak if we were to call
18820 guess_partial_die_structure_name multiple times. */
18824 /* If we found a reference attribute and the DIE has no name, try
18825 to find a name in the referred to DIE. */
18827 if (name == NULL && has_specification)
18829 struct partial_die_info *spec_die;
18831 spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
18833 spec_die->fixup (cu);
18835 if (spec_die->name)
18837 name = spec_die->name;
18839 /* Copy DW_AT_external attribute if it is set. */
18840 if (spec_die->is_external)
18841 is_external = spec_die->is_external;
18845 /* Set default names for some unnamed DIEs. */
18847 if (name == NULL && tag == DW_TAG_namespace)
18848 name = CP_ANONYMOUS_NAMESPACE_STR;
18850 /* If there is no parent die to provide a namespace, and there are
18851 children, see if we can determine the namespace from their linkage
18853 if (cu->language == language_cplus
18854 && !VEC_empty (dwarf2_section_info_def,
18855 cu->per_cu->dwarf2_per_objfile->types)
18856 && die_parent == NULL
18858 && (tag == DW_TAG_class_type
18859 || tag == DW_TAG_structure_type
18860 || tag == DW_TAG_union_type))
18861 guess_partial_die_structure_name (this, cu);
18863 /* GCC might emit a nameless struct or union that has a linkage
18864 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18866 && (tag == DW_TAG_class_type
18867 || tag == DW_TAG_interface_type
18868 || tag == DW_TAG_structure_type
18869 || tag == DW_TAG_union_type)
18870 && linkage_name != NULL)
18874 demangled = gdb_demangle (linkage_name, DMGL_TYPES);
18879 /* Strip any leading namespaces/classes, keep only the base name.
18880 DW_AT_name for named DIEs does not contain the prefixes. */
18881 base = strrchr (demangled, ':');
18882 if (base && base > demangled && base[-1] == ':')
18887 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18890 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18891 base, strlen (base)));
18899 /* Read an attribute value described by an attribute form. */
18901 static const gdb_byte *
18902 read_attribute_value (const struct die_reader_specs *reader,
18903 struct attribute *attr, unsigned form,
18904 LONGEST implicit_const, const gdb_byte *info_ptr)
18906 struct dwarf2_cu *cu = reader->cu;
18907 struct dwarf2_per_objfile *dwarf2_per_objfile
18908 = cu->per_cu->dwarf2_per_objfile;
18909 struct objfile *objfile = dwarf2_per_objfile->objfile;
18910 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18911 bfd *abfd = reader->abfd;
18912 struct comp_unit_head *cu_header = &cu->header;
18913 unsigned int bytes_read;
18914 struct dwarf_block *blk;
18916 attr->form = (enum dwarf_form) form;
18919 case DW_FORM_ref_addr:
18920 if (cu->header.version == 2)
18921 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
18923 DW_UNSND (attr) = read_offset (abfd, info_ptr,
18924 &cu->header, &bytes_read);
18925 info_ptr += bytes_read;
18927 case DW_FORM_GNU_ref_alt:
18928 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
18929 info_ptr += bytes_read;
18932 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
18933 DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
18934 info_ptr += bytes_read;
18936 case DW_FORM_block2:
18937 blk = dwarf_alloc_block (cu);
18938 blk->size = read_2_bytes (abfd, info_ptr);
18940 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
18941 info_ptr += blk->size;
18942 DW_BLOCK (attr) = blk;
18944 case DW_FORM_block4:
18945 blk = dwarf_alloc_block (cu);
18946 blk->size = read_4_bytes (abfd, info_ptr);
18948 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
18949 info_ptr += blk->size;
18950 DW_BLOCK (attr) = blk;
18952 case DW_FORM_data2:
18953 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
18956 case DW_FORM_data4:
18957 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
18960 case DW_FORM_data8:
18961 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
18964 case DW_FORM_data16:
18965 blk = dwarf_alloc_block (cu);
18967 blk->data = read_n_bytes (abfd, info_ptr, 16);
18969 DW_BLOCK (attr) = blk;
18971 case DW_FORM_sec_offset:
18972 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
18973 info_ptr += bytes_read;
18975 case DW_FORM_string:
18976 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
18977 DW_STRING_IS_CANONICAL (attr) = 0;
18978 info_ptr += bytes_read;
18981 if (!cu->per_cu->is_dwz)
18983 DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
18984 abfd, info_ptr, cu_header,
18986 DW_STRING_IS_CANONICAL (attr) = 0;
18987 info_ptr += bytes_read;
18991 case DW_FORM_line_strp:
18992 if (!cu->per_cu->is_dwz)
18994 DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
18996 cu_header, &bytes_read);
18997 DW_STRING_IS_CANONICAL (attr) = 0;
18998 info_ptr += bytes_read;
19002 case DW_FORM_GNU_strp_alt:
19004 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19005 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19008 DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19010 DW_STRING_IS_CANONICAL (attr) = 0;
19011 info_ptr += bytes_read;
19014 case DW_FORM_exprloc:
19015 case DW_FORM_block:
19016 blk = dwarf_alloc_block (cu);
19017 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19018 info_ptr += bytes_read;
19019 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19020 info_ptr += blk->size;
19021 DW_BLOCK (attr) = blk;
19023 case DW_FORM_block1:
19024 blk = dwarf_alloc_block (cu);
19025 blk->size = read_1_byte (abfd, info_ptr);
19027 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19028 info_ptr += blk->size;
19029 DW_BLOCK (attr) = blk;
19031 case DW_FORM_data1:
19032 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19036 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19039 case DW_FORM_flag_present:
19040 DW_UNSND (attr) = 1;
19042 case DW_FORM_sdata:
19043 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19044 info_ptr += bytes_read;
19046 case DW_FORM_udata:
19047 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19048 info_ptr += bytes_read;
19051 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19052 + read_1_byte (abfd, info_ptr));
19056 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19057 + read_2_bytes (abfd, info_ptr));
19061 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19062 + read_4_bytes (abfd, info_ptr));
19066 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19067 + read_8_bytes (abfd, info_ptr));
19070 case DW_FORM_ref_sig8:
19071 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19074 case DW_FORM_ref_udata:
19075 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19076 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19077 info_ptr += bytes_read;
19079 case DW_FORM_indirect:
19080 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19081 info_ptr += bytes_read;
19082 if (form == DW_FORM_implicit_const)
19084 implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19085 info_ptr += bytes_read;
19087 info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19090 case DW_FORM_implicit_const:
19091 DW_SND (attr) = implicit_const;
19093 case DW_FORM_GNU_addr_index:
19094 if (reader->dwo_file == NULL)
19096 /* For now flag a hard error.
19097 Later we can turn this into a complaint. */
19098 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19099 dwarf_form_name (form),
19100 bfd_get_filename (abfd));
19102 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19103 info_ptr += bytes_read;
19105 case DW_FORM_GNU_str_index:
19106 if (reader->dwo_file == NULL)
19108 /* For now flag a hard error.
19109 Later we can turn this into a complaint if warranted. */
19110 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19111 dwarf_form_name (form),
19112 bfd_get_filename (abfd));
19115 ULONGEST str_index =
19116 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19118 DW_STRING (attr) = read_str_index (reader, str_index);
19119 DW_STRING_IS_CANONICAL (attr) = 0;
19120 info_ptr += bytes_read;
19124 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19125 dwarf_form_name (form),
19126 bfd_get_filename (abfd));
19130 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19131 attr->form = DW_FORM_GNU_ref_alt;
19133 /* We have seen instances where the compiler tried to emit a byte
19134 size attribute of -1 which ended up being encoded as an unsigned
19135 0xffffffff. Although 0xffffffff is technically a valid size value,
19136 an object of this size seems pretty unlikely so we can relatively
19137 safely treat these cases as if the size attribute was invalid and
19138 treat them as zero by default. */
19139 if (attr->name == DW_AT_byte_size
19140 && form == DW_FORM_data4
19141 && DW_UNSND (attr) >= 0xffffffff)
19144 (&symfile_complaints,
19145 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19146 hex_string (DW_UNSND (attr)));
19147 DW_UNSND (attr) = 0;
19153 /* Read an attribute described by an abbreviated attribute. */
19155 static const gdb_byte *
19156 read_attribute (const struct die_reader_specs *reader,
19157 struct attribute *attr, struct attr_abbrev *abbrev,
19158 const gdb_byte *info_ptr)
19160 attr->name = abbrev->name;
19161 return read_attribute_value (reader, attr, abbrev->form,
19162 abbrev->implicit_const, info_ptr);
19165 /* Read dwarf information from a buffer. */
19167 static unsigned int
19168 read_1_byte (bfd *abfd, const gdb_byte *buf)
19170 return bfd_get_8 (abfd, buf);
19174 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19176 return bfd_get_signed_8 (abfd, buf);
19179 static unsigned int
19180 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19182 return bfd_get_16 (abfd, buf);
19186 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19188 return bfd_get_signed_16 (abfd, buf);
19191 static unsigned int
19192 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19194 return bfd_get_32 (abfd, buf);
19198 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19200 return bfd_get_signed_32 (abfd, buf);
19204 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19206 return bfd_get_64 (abfd, buf);
19210 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19211 unsigned int *bytes_read)
19213 struct comp_unit_head *cu_header = &cu->header;
19214 CORE_ADDR retval = 0;
19216 if (cu_header->signed_addr_p)
19218 switch (cu_header->addr_size)
19221 retval = bfd_get_signed_16 (abfd, buf);
19224 retval = bfd_get_signed_32 (abfd, buf);
19227 retval = bfd_get_signed_64 (abfd, buf);
19230 internal_error (__FILE__, __LINE__,
19231 _("read_address: bad switch, signed [in module %s]"),
19232 bfd_get_filename (abfd));
19237 switch (cu_header->addr_size)
19240 retval = bfd_get_16 (abfd, buf);
19243 retval = bfd_get_32 (abfd, buf);
19246 retval = bfd_get_64 (abfd, buf);
19249 internal_error (__FILE__, __LINE__,
19250 _("read_address: bad switch, "
19251 "unsigned [in module %s]"),
19252 bfd_get_filename (abfd));
19256 *bytes_read = cu_header->addr_size;
19260 /* Read the initial length from a section. The (draft) DWARF 3
19261 specification allows the initial length to take up either 4 bytes
19262 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19263 bytes describe the length and all offsets will be 8 bytes in length
19266 An older, non-standard 64-bit format is also handled by this
19267 function. The older format in question stores the initial length
19268 as an 8-byte quantity without an escape value. Lengths greater
19269 than 2^32 aren't very common which means that the initial 4 bytes
19270 is almost always zero. Since a length value of zero doesn't make
19271 sense for the 32-bit format, this initial zero can be considered to
19272 be an escape value which indicates the presence of the older 64-bit
19273 format. As written, the code can't detect (old format) lengths
19274 greater than 4GB. If it becomes necessary to handle lengths
19275 somewhat larger than 4GB, we could allow other small values (such
19276 as the non-sensical values of 1, 2, and 3) to also be used as
19277 escape values indicating the presence of the old format.
19279 The value returned via bytes_read should be used to increment the
19280 relevant pointer after calling read_initial_length().
19282 [ Note: read_initial_length() and read_offset() are based on the
19283 document entitled "DWARF Debugging Information Format", revision
19284 3, draft 8, dated November 19, 2001. This document was obtained
19287 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19289 This document is only a draft and is subject to change. (So beware.)
19291 Details regarding the older, non-standard 64-bit format were
19292 determined empirically by examining 64-bit ELF files produced by
19293 the SGI toolchain on an IRIX 6.5 machine.
19295 - Kevin, July 16, 2002
19299 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19301 LONGEST length = bfd_get_32 (abfd, buf);
19303 if (length == 0xffffffff)
19305 length = bfd_get_64 (abfd, buf + 4);
19308 else if (length == 0)
19310 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19311 length = bfd_get_64 (abfd, buf);
19322 /* Cover function for read_initial_length.
19323 Returns the length of the object at BUF, and stores the size of the
19324 initial length in *BYTES_READ and stores the size that offsets will be in
19326 If the initial length size is not equivalent to that specified in
19327 CU_HEADER then issue a complaint.
19328 This is useful when reading non-comp-unit headers. */
19331 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19332 const struct comp_unit_head *cu_header,
19333 unsigned int *bytes_read,
19334 unsigned int *offset_size)
19336 LONGEST length = read_initial_length (abfd, buf, bytes_read);
19338 gdb_assert (cu_header->initial_length_size == 4
19339 || cu_header->initial_length_size == 8
19340 || cu_header->initial_length_size == 12);
19342 if (cu_header->initial_length_size != *bytes_read)
19343 complaint (&symfile_complaints,
19344 _("intermixed 32-bit and 64-bit DWARF sections"));
19346 *offset_size = (*bytes_read == 4) ? 4 : 8;
19350 /* Read an offset from the data stream. The size of the offset is
19351 given by cu_header->offset_size. */
19354 read_offset (bfd *abfd, const gdb_byte *buf,
19355 const struct comp_unit_head *cu_header,
19356 unsigned int *bytes_read)
19358 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19360 *bytes_read = cu_header->offset_size;
19364 /* Read an offset from the data stream. */
19367 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19369 LONGEST retval = 0;
19371 switch (offset_size)
19374 retval = bfd_get_32 (abfd, buf);
19377 retval = bfd_get_64 (abfd, buf);
19380 internal_error (__FILE__, __LINE__,
19381 _("read_offset_1: bad switch [in module %s]"),
19382 bfd_get_filename (abfd));
19388 static const gdb_byte *
19389 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19391 /* If the size of a host char is 8 bits, we can return a pointer
19392 to the buffer, otherwise we have to copy the data to a buffer
19393 allocated on the temporary obstack. */
19394 gdb_assert (HOST_CHAR_BIT == 8);
19398 static const char *
19399 read_direct_string (bfd *abfd, const gdb_byte *buf,
19400 unsigned int *bytes_read_ptr)
19402 /* If the size of a host char is 8 bits, we can return a pointer
19403 to the string, otherwise we have to copy the string to a buffer
19404 allocated on the temporary obstack. */
19405 gdb_assert (HOST_CHAR_BIT == 8);
19408 *bytes_read_ptr = 1;
19411 *bytes_read_ptr = strlen ((const char *) buf) + 1;
19412 return (const char *) buf;
19415 /* Return pointer to string at section SECT offset STR_OFFSET with error
19416 reporting strings FORM_NAME and SECT_NAME. */
19418 static const char *
19419 read_indirect_string_at_offset_from (struct objfile *objfile,
19420 bfd *abfd, LONGEST str_offset,
19421 struct dwarf2_section_info *sect,
19422 const char *form_name,
19423 const char *sect_name)
19425 dwarf2_read_section (objfile, sect);
19426 if (sect->buffer == NULL)
19427 error (_("%s used without %s section [in module %s]"),
19428 form_name, sect_name, bfd_get_filename (abfd));
19429 if (str_offset >= sect->size)
19430 error (_("%s pointing outside of %s section [in module %s]"),
19431 form_name, sect_name, bfd_get_filename (abfd));
19432 gdb_assert (HOST_CHAR_BIT == 8);
19433 if (sect->buffer[str_offset] == '\0')
19435 return (const char *) (sect->buffer + str_offset);
19438 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19440 static const char *
19441 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19442 bfd *abfd, LONGEST str_offset)
19444 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19446 &dwarf2_per_objfile->str,
19447 "DW_FORM_strp", ".debug_str");
19450 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19452 static const char *
19453 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19454 bfd *abfd, LONGEST str_offset)
19456 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19458 &dwarf2_per_objfile->line_str,
19459 "DW_FORM_line_strp",
19460 ".debug_line_str");
19463 /* Read a string at offset STR_OFFSET in the .debug_str section from
19464 the .dwz file DWZ. Throw an error if the offset is too large. If
19465 the string consists of a single NUL byte, return NULL; otherwise
19466 return a pointer to the string. */
19468 static const char *
19469 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19470 LONGEST str_offset)
19472 dwarf2_read_section (objfile, &dwz->str);
19474 if (dwz->str.buffer == NULL)
19475 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19476 "section [in module %s]"),
19477 bfd_get_filename (dwz->dwz_bfd));
19478 if (str_offset >= dwz->str.size)
19479 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19480 ".debug_str section [in module %s]"),
19481 bfd_get_filename (dwz->dwz_bfd));
19482 gdb_assert (HOST_CHAR_BIT == 8);
19483 if (dwz->str.buffer[str_offset] == '\0')
19485 return (const char *) (dwz->str.buffer + str_offset);
19488 /* Return pointer to string at .debug_str offset as read from BUF.
19489 BUF is assumed to be in a compilation unit described by CU_HEADER.
19490 Return *BYTES_READ_PTR count of bytes read from BUF. */
19492 static const char *
19493 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19494 const gdb_byte *buf,
19495 const struct comp_unit_head *cu_header,
19496 unsigned int *bytes_read_ptr)
19498 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19500 return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19503 /* Return pointer to string at .debug_line_str offset as read from BUF.
19504 BUF is assumed to be in a compilation unit described by CU_HEADER.
19505 Return *BYTES_READ_PTR count of bytes read from BUF. */
19507 static const char *
19508 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19509 bfd *abfd, const gdb_byte *buf,
19510 const struct comp_unit_head *cu_header,
19511 unsigned int *bytes_read_ptr)
19513 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19515 return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19520 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19521 unsigned int *bytes_read_ptr)
19524 unsigned int num_read;
19526 unsigned char byte;
19533 byte = bfd_get_8 (abfd, buf);
19536 result |= ((ULONGEST) (byte & 127) << shift);
19537 if ((byte & 128) == 0)
19543 *bytes_read_ptr = num_read;
19548 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19549 unsigned int *bytes_read_ptr)
19552 int shift, num_read;
19553 unsigned char byte;
19560 byte = bfd_get_8 (abfd, buf);
19563 result |= ((LONGEST) (byte & 127) << shift);
19565 if ((byte & 128) == 0)
19570 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19571 result |= -(((LONGEST) 1) << shift);
19572 *bytes_read_ptr = num_read;
19576 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19577 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19578 ADDR_SIZE is the size of addresses from the CU header. */
19581 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19582 unsigned int addr_index, ULONGEST addr_base, int addr_size)
19584 struct objfile *objfile = dwarf2_per_objfile->objfile;
19585 bfd *abfd = objfile->obfd;
19586 const gdb_byte *info_ptr;
19588 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19589 if (dwarf2_per_objfile->addr.buffer == NULL)
19590 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19591 objfile_name (objfile));
19592 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19593 error (_("DW_FORM_addr_index pointing outside of "
19594 ".debug_addr section [in module %s]"),
19595 objfile_name (objfile));
19596 info_ptr = (dwarf2_per_objfile->addr.buffer
19597 + addr_base + addr_index * addr_size);
19598 if (addr_size == 4)
19599 return bfd_get_32 (abfd, info_ptr);
19601 return bfd_get_64 (abfd, info_ptr);
19604 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19607 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19609 return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19610 cu->addr_base, cu->header.addr_size);
19613 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19616 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19617 unsigned int *bytes_read)
19619 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19620 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19622 return read_addr_index (cu, addr_index);
19625 /* Data structure to pass results from dwarf2_read_addr_index_reader
19626 back to dwarf2_read_addr_index. */
19628 struct dwarf2_read_addr_index_data
19630 ULONGEST addr_base;
19634 /* die_reader_func for dwarf2_read_addr_index. */
19637 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19638 const gdb_byte *info_ptr,
19639 struct die_info *comp_unit_die,
19643 struct dwarf2_cu *cu = reader->cu;
19644 struct dwarf2_read_addr_index_data *aidata =
19645 (struct dwarf2_read_addr_index_data *) data;
19647 aidata->addr_base = cu->addr_base;
19648 aidata->addr_size = cu->header.addr_size;
19651 /* Given an index in .debug_addr, fetch the value.
19652 NOTE: This can be called during dwarf expression evaluation,
19653 long after the debug information has been read, and thus per_cu->cu
19654 may no longer exist. */
19657 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19658 unsigned int addr_index)
19660 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19661 struct dwarf2_cu *cu = per_cu->cu;
19662 ULONGEST addr_base;
19665 /* We need addr_base and addr_size.
19666 If we don't have PER_CU->cu, we have to get it.
19667 Nasty, but the alternative is storing the needed info in PER_CU,
19668 which at this point doesn't seem justified: it's not clear how frequently
19669 it would get used and it would increase the size of every PER_CU.
19670 Entry points like dwarf2_per_cu_addr_size do a similar thing
19671 so we're not in uncharted territory here.
19672 Alas we need to be a bit more complicated as addr_base is contained
19675 We don't need to read the entire CU(/TU).
19676 We just need the header and top level die.
19678 IWBN to use the aging mechanism to let us lazily later discard the CU.
19679 For now we skip this optimization. */
19683 addr_base = cu->addr_base;
19684 addr_size = cu->header.addr_size;
19688 struct dwarf2_read_addr_index_data aidata;
19690 /* Note: We can't use init_cutu_and_read_dies_simple here,
19691 we need addr_base. */
19692 init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19693 dwarf2_read_addr_index_reader, &aidata);
19694 addr_base = aidata.addr_base;
19695 addr_size = aidata.addr_size;
19698 return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19702 /* Given a DW_FORM_GNU_str_index, fetch the string.
19703 This is only used by the Fission support. */
19705 static const char *
19706 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19708 struct dwarf2_cu *cu = reader->cu;
19709 struct dwarf2_per_objfile *dwarf2_per_objfile
19710 = cu->per_cu->dwarf2_per_objfile;
19711 struct objfile *objfile = dwarf2_per_objfile->objfile;
19712 const char *objf_name = objfile_name (objfile);
19713 bfd *abfd = objfile->obfd;
19714 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19715 struct dwarf2_section_info *str_offsets_section =
19716 &reader->dwo_file->sections.str_offsets;
19717 const gdb_byte *info_ptr;
19718 ULONGEST str_offset;
19719 static const char form_name[] = "DW_FORM_GNU_str_index";
19721 dwarf2_read_section (objfile, str_section);
19722 dwarf2_read_section (objfile, str_offsets_section);
19723 if (str_section->buffer == NULL)
19724 error (_("%s used without .debug_str.dwo section"
19725 " in CU at offset %s [in module %s]"),
19726 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19727 if (str_offsets_section->buffer == NULL)
19728 error (_("%s used without .debug_str_offsets.dwo section"
19729 " in CU at offset %s [in module %s]"),
19730 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19731 if (str_index * cu->header.offset_size >= str_offsets_section->size)
19732 error (_("%s pointing outside of .debug_str_offsets.dwo"
19733 " section in CU at offset %s [in module %s]"),
19734 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19735 info_ptr = (str_offsets_section->buffer
19736 + str_index * cu->header.offset_size);
19737 if (cu->header.offset_size == 4)
19738 str_offset = bfd_get_32 (abfd, info_ptr);
19740 str_offset = bfd_get_64 (abfd, info_ptr);
19741 if (str_offset >= str_section->size)
19742 error (_("Offset from %s pointing outside of"
19743 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19744 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19745 return (const char *) (str_section->buffer + str_offset);
19748 /* Return the length of an LEB128 number in BUF. */
19751 leb128_size (const gdb_byte *buf)
19753 const gdb_byte *begin = buf;
19759 if ((byte & 128) == 0)
19760 return buf - begin;
19765 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19774 cu->language = language_c;
19777 case DW_LANG_C_plus_plus:
19778 case DW_LANG_C_plus_plus_11:
19779 case DW_LANG_C_plus_plus_14:
19780 cu->language = language_cplus;
19783 cu->language = language_d;
19785 case DW_LANG_Fortran77:
19786 case DW_LANG_Fortran90:
19787 case DW_LANG_Fortran95:
19788 case DW_LANG_Fortran03:
19789 case DW_LANG_Fortran08:
19790 cu->language = language_fortran;
19793 cu->language = language_go;
19795 case DW_LANG_Mips_Assembler:
19796 cu->language = language_asm;
19798 case DW_LANG_Ada83:
19799 case DW_LANG_Ada95:
19800 cu->language = language_ada;
19802 case DW_LANG_Modula2:
19803 cu->language = language_m2;
19805 case DW_LANG_Pascal83:
19806 cu->language = language_pascal;
19809 cu->language = language_objc;
19812 case DW_LANG_Rust_old:
19813 cu->language = language_rust;
19815 case DW_LANG_Cobol74:
19816 case DW_LANG_Cobol85:
19818 cu->language = language_minimal;
19821 cu->language_defn = language_def (cu->language);
19824 /* Return the named attribute or NULL if not there. */
19826 static struct attribute *
19827 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19832 struct attribute *spec = NULL;
19834 for (i = 0; i < die->num_attrs; ++i)
19836 if (die->attrs[i].name == name)
19837 return &die->attrs[i];
19838 if (die->attrs[i].name == DW_AT_specification
19839 || die->attrs[i].name == DW_AT_abstract_origin)
19840 spec = &die->attrs[i];
19846 die = follow_die_ref (die, spec, &cu);
19852 /* Return the named attribute or NULL if not there,
19853 but do not follow DW_AT_specification, etc.
19854 This is for use in contexts where we're reading .debug_types dies.
19855 Following DW_AT_specification, DW_AT_abstract_origin will take us
19856 back up the chain, and we want to go down. */
19858 static struct attribute *
19859 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
19863 for (i = 0; i < die->num_attrs; ++i)
19864 if (die->attrs[i].name == name)
19865 return &die->attrs[i];
19870 /* Return the string associated with a string-typed attribute, or NULL if it
19871 is either not found or is of an incorrect type. */
19873 static const char *
19874 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19876 struct attribute *attr;
19877 const char *str = NULL;
19879 attr = dwarf2_attr (die, name, cu);
19883 if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
19884 || attr->form == DW_FORM_string
19885 || attr->form == DW_FORM_GNU_str_index
19886 || attr->form == DW_FORM_GNU_strp_alt)
19887 str = DW_STRING (attr);
19889 complaint (&symfile_complaints,
19890 _("string type expected for attribute %s for "
19891 "DIE at %s in module %s"),
19892 dwarf_attr_name (name), sect_offset_str (die->sect_off),
19893 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
19899 /* Return non-zero iff the attribute NAME is defined for the given DIE,
19900 and holds a non-zero value. This function should only be used for
19901 DW_FORM_flag or DW_FORM_flag_present attributes. */
19904 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
19906 struct attribute *attr = dwarf2_attr (die, name, cu);
19908 return (attr && DW_UNSND (attr));
19912 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
19914 /* A DIE is a declaration if it has a DW_AT_declaration attribute
19915 which value is non-zero. However, we have to be careful with
19916 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
19917 (via dwarf2_flag_true_p) follows this attribute. So we may
19918 end up accidently finding a declaration attribute that belongs
19919 to a different DIE referenced by the specification attribute,
19920 even though the given DIE does not have a declaration attribute. */
19921 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
19922 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
19925 /* Return the die giving the specification for DIE, if there is
19926 one. *SPEC_CU is the CU containing DIE on input, and the CU
19927 containing the return value on output. If there is no
19928 specification, but there is an abstract origin, that is
19931 static struct die_info *
19932 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
19934 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
19937 if (spec_attr == NULL)
19938 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
19940 if (spec_attr == NULL)
19943 return follow_die_ref (die, spec_attr, spec_cu);
19946 /* Stub for free_line_header to match void * callback types. */
19949 free_line_header_voidp (void *arg)
19951 struct line_header *lh = (struct line_header *) arg;
19957 line_header::add_include_dir (const char *include_dir)
19959 if (dwarf_line_debug >= 2)
19960 fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
19961 include_dirs.size () + 1, include_dir);
19963 include_dirs.push_back (include_dir);
19967 line_header::add_file_name (const char *name,
19969 unsigned int mod_time,
19970 unsigned int length)
19972 if (dwarf_line_debug >= 2)
19973 fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
19974 (unsigned) file_names.size () + 1, name);
19976 file_names.emplace_back (name, d_index, mod_time, length);
19979 /* A convenience function to find the proper .debug_line section for a CU. */
19981 static struct dwarf2_section_info *
19982 get_debug_line_section (struct dwarf2_cu *cu)
19984 struct dwarf2_section_info *section;
19985 struct dwarf2_per_objfile *dwarf2_per_objfile
19986 = cu->per_cu->dwarf2_per_objfile;
19988 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
19990 if (cu->dwo_unit && cu->per_cu->is_debug_types)
19991 section = &cu->dwo_unit->dwo_file->sections.line;
19992 else if (cu->per_cu->is_dwz)
19994 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19996 section = &dwz->line;
19999 section = &dwarf2_per_objfile->line;
20004 /* Read directory or file name entry format, starting with byte of
20005 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20006 entries count and the entries themselves in the described entry
20010 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20011 bfd *abfd, const gdb_byte **bufp,
20012 struct line_header *lh,
20013 const struct comp_unit_head *cu_header,
20014 void (*callback) (struct line_header *lh,
20017 unsigned int mod_time,
20018 unsigned int length))
20020 gdb_byte format_count, formati;
20021 ULONGEST data_count, datai;
20022 const gdb_byte *buf = *bufp;
20023 const gdb_byte *format_header_data;
20024 unsigned int bytes_read;
20026 format_count = read_1_byte (abfd, buf);
20028 format_header_data = buf;
20029 for (formati = 0; formati < format_count; formati++)
20031 read_unsigned_leb128 (abfd, buf, &bytes_read);
20033 read_unsigned_leb128 (abfd, buf, &bytes_read);
20037 data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20039 for (datai = 0; datai < data_count; datai++)
20041 const gdb_byte *format = format_header_data;
20042 struct file_entry fe;
20044 for (formati = 0; formati < format_count; formati++)
20046 ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20047 format += bytes_read;
20049 ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
20050 format += bytes_read;
20052 gdb::optional<const char *> string;
20053 gdb::optional<unsigned int> uint;
20057 case DW_FORM_string:
20058 string.emplace (read_direct_string (abfd, buf, &bytes_read));
20062 case DW_FORM_line_strp:
20063 string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20070 case DW_FORM_data1:
20071 uint.emplace (read_1_byte (abfd, buf));
20075 case DW_FORM_data2:
20076 uint.emplace (read_2_bytes (abfd, buf));
20080 case DW_FORM_data4:
20081 uint.emplace (read_4_bytes (abfd, buf));
20085 case DW_FORM_data8:
20086 uint.emplace (read_8_bytes (abfd, buf));
20090 case DW_FORM_udata:
20091 uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20095 case DW_FORM_block:
20096 /* It is valid only for DW_LNCT_timestamp which is ignored by
20101 switch (content_type)
20104 if (string.has_value ())
20107 case DW_LNCT_directory_index:
20108 if (uint.has_value ())
20109 fe.d_index = (dir_index) *uint;
20111 case DW_LNCT_timestamp:
20112 if (uint.has_value ())
20113 fe.mod_time = *uint;
20116 if (uint.has_value ())
20122 complaint (&symfile_complaints,
20123 _("Unknown format content type %s"),
20124 pulongest (content_type));
20128 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20134 /* Read the statement program header starting at OFFSET in
20135 .debug_line, or .debug_line.dwo. Return a pointer
20136 to a struct line_header, allocated using xmalloc.
20137 Returns NULL if there is a problem reading the header, e.g., if it
20138 has a version we don't understand.
20140 NOTE: the strings in the include directory and file name tables of
20141 the returned object point into the dwarf line section buffer,
20142 and must not be freed. */
20144 static line_header_up
20145 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20147 const gdb_byte *line_ptr;
20148 unsigned int bytes_read, offset_size;
20150 const char *cur_dir, *cur_file;
20151 struct dwarf2_section_info *section;
20153 struct dwarf2_per_objfile *dwarf2_per_objfile
20154 = cu->per_cu->dwarf2_per_objfile;
20156 section = get_debug_line_section (cu);
20157 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20158 if (section->buffer == NULL)
20160 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20161 complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
20163 complaint (&symfile_complaints, _("missing .debug_line section"));
20167 /* We can't do this until we know the section is non-empty.
20168 Only then do we know we have such a section. */
20169 abfd = get_section_bfd_owner (section);
20171 /* Make sure that at least there's room for the total_length field.
20172 That could be 12 bytes long, but we're just going to fudge that. */
20173 if (to_underlying (sect_off) + 4 >= section->size)
20175 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20179 line_header_up lh (new line_header ());
20181 lh->sect_off = sect_off;
20182 lh->offset_in_dwz = cu->per_cu->is_dwz;
20184 line_ptr = section->buffer + to_underlying (sect_off);
20186 /* Read in the header. */
20188 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20189 &bytes_read, &offset_size);
20190 line_ptr += bytes_read;
20191 if (line_ptr + lh->total_length > (section->buffer + section->size))
20193 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20196 lh->statement_program_end = line_ptr + lh->total_length;
20197 lh->version = read_2_bytes (abfd, line_ptr);
20199 if (lh->version > 5)
20201 /* This is a version we don't understand. The format could have
20202 changed in ways we don't handle properly so just punt. */
20203 complaint (&symfile_complaints,
20204 _("unsupported version in .debug_line section"));
20207 if (lh->version >= 5)
20209 gdb_byte segment_selector_size;
20211 /* Skip address size. */
20212 read_1_byte (abfd, line_ptr);
20215 segment_selector_size = read_1_byte (abfd, line_ptr);
20217 if (segment_selector_size != 0)
20219 complaint (&symfile_complaints,
20220 _("unsupported segment selector size %u "
20221 "in .debug_line section"),
20222 segment_selector_size);
20226 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20227 line_ptr += offset_size;
20228 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20230 if (lh->version >= 4)
20232 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20236 lh->maximum_ops_per_instruction = 1;
20238 if (lh->maximum_ops_per_instruction == 0)
20240 lh->maximum_ops_per_instruction = 1;
20241 complaint (&symfile_complaints,
20242 _("invalid maximum_ops_per_instruction "
20243 "in `.debug_line' section"));
20246 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20248 lh->line_base = read_1_signed_byte (abfd, line_ptr);
20250 lh->line_range = read_1_byte (abfd, line_ptr);
20252 lh->opcode_base = read_1_byte (abfd, line_ptr);
20254 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20256 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
20257 for (i = 1; i < lh->opcode_base; ++i)
20259 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20263 if (lh->version >= 5)
20265 /* Read directory table. */
20266 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20268 [] (struct line_header *lh, const char *name,
20269 dir_index d_index, unsigned int mod_time,
20270 unsigned int length)
20272 lh->add_include_dir (name);
20275 /* Read file name table. */
20276 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20278 [] (struct line_header *lh, const char *name,
20279 dir_index d_index, unsigned int mod_time,
20280 unsigned int length)
20282 lh->add_file_name (name, d_index, mod_time, length);
20287 /* Read directory table. */
20288 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20290 line_ptr += bytes_read;
20291 lh->add_include_dir (cur_dir);
20293 line_ptr += bytes_read;
20295 /* Read file name table. */
20296 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20298 unsigned int mod_time, length;
20301 line_ptr += bytes_read;
20302 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20303 line_ptr += bytes_read;
20304 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20305 line_ptr += bytes_read;
20306 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20307 line_ptr += bytes_read;
20309 lh->add_file_name (cur_file, d_index, mod_time, length);
20311 line_ptr += bytes_read;
20313 lh->statement_program_start = line_ptr;
20315 if (line_ptr > (section->buffer + section->size))
20316 complaint (&symfile_complaints,
20317 _("line number info header doesn't "
20318 "fit in `.debug_line' section"));
20323 /* Subroutine of dwarf_decode_lines to simplify it.
20324 Return the file name of the psymtab for included file FILE_INDEX
20325 in line header LH of PST.
20326 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20327 If space for the result is malloc'd, *NAME_HOLDER will be set.
20328 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20330 static const char *
20331 psymtab_include_file_name (const struct line_header *lh, int file_index,
20332 const struct partial_symtab *pst,
20333 const char *comp_dir,
20334 gdb::unique_xmalloc_ptr<char> *name_holder)
20336 const file_entry &fe = lh->file_names[file_index];
20337 const char *include_name = fe.name;
20338 const char *include_name_to_compare = include_name;
20339 const char *pst_filename;
20342 const char *dir_name = fe.include_dir (lh);
20344 gdb::unique_xmalloc_ptr<char> hold_compare;
20345 if (!IS_ABSOLUTE_PATH (include_name)
20346 && (dir_name != NULL || comp_dir != NULL))
20348 /* Avoid creating a duplicate psymtab for PST.
20349 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20350 Before we do the comparison, however, we need to account
20351 for DIR_NAME and COMP_DIR.
20352 First prepend dir_name (if non-NULL). If we still don't
20353 have an absolute path prepend comp_dir (if non-NULL).
20354 However, the directory we record in the include-file's
20355 psymtab does not contain COMP_DIR (to match the
20356 corresponding symtab(s)).
20361 bash$ gcc -g ./hello.c
20362 include_name = "hello.c"
20364 DW_AT_comp_dir = comp_dir = "/tmp"
20365 DW_AT_name = "./hello.c"
20369 if (dir_name != NULL)
20371 name_holder->reset (concat (dir_name, SLASH_STRING,
20372 include_name, (char *) NULL));
20373 include_name = name_holder->get ();
20374 include_name_to_compare = include_name;
20376 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20378 hold_compare.reset (concat (comp_dir, SLASH_STRING,
20379 include_name, (char *) NULL));
20380 include_name_to_compare = hold_compare.get ();
20384 pst_filename = pst->filename;
20385 gdb::unique_xmalloc_ptr<char> copied_name;
20386 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20388 copied_name.reset (concat (pst->dirname, SLASH_STRING,
20389 pst_filename, (char *) NULL));
20390 pst_filename = copied_name.get ();
20393 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20397 return include_name;
20400 /* State machine to track the state of the line number program. */
20402 class lnp_state_machine
20405 /* Initialize a machine state for the start of a line number
20407 lnp_state_machine (gdbarch *arch, line_header *lh, bool record_lines_p);
20409 file_entry *current_file ()
20411 /* lh->file_names is 0-based, but the file name numbers in the
20412 statement program are 1-based. */
20413 return m_line_header->file_name_at (m_file);
20416 /* Record the line in the state machine. END_SEQUENCE is true if
20417 we're processing the end of a sequence. */
20418 void record_line (bool end_sequence);
20420 /* Check address and if invalid nop-out the rest of the lines in this
20422 void check_line_address (struct dwarf2_cu *cu,
20423 const gdb_byte *line_ptr,
20424 CORE_ADDR lowpc, CORE_ADDR address);
20426 void handle_set_discriminator (unsigned int discriminator)
20428 m_discriminator = discriminator;
20429 m_line_has_non_zero_discriminator |= discriminator != 0;
20432 /* Handle DW_LNE_set_address. */
20433 void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20436 address += baseaddr;
20437 m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20440 /* Handle DW_LNS_advance_pc. */
20441 void handle_advance_pc (CORE_ADDR adjust);
20443 /* Handle a special opcode. */
20444 void handle_special_opcode (unsigned char op_code);
20446 /* Handle DW_LNS_advance_line. */
20447 void handle_advance_line (int line_delta)
20449 advance_line (line_delta);
20452 /* Handle DW_LNS_set_file. */
20453 void handle_set_file (file_name_index file);
20455 /* Handle DW_LNS_negate_stmt. */
20456 void handle_negate_stmt ()
20458 m_is_stmt = !m_is_stmt;
20461 /* Handle DW_LNS_const_add_pc. */
20462 void handle_const_add_pc ();
20464 /* Handle DW_LNS_fixed_advance_pc. */
20465 void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20467 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20471 /* Handle DW_LNS_copy. */
20472 void handle_copy ()
20474 record_line (false);
20475 m_discriminator = 0;
20478 /* Handle DW_LNE_end_sequence. */
20479 void handle_end_sequence ()
20481 m_record_line_callback = ::record_line;
20485 /* Advance the line by LINE_DELTA. */
20486 void advance_line (int line_delta)
20488 m_line += line_delta;
20490 if (line_delta != 0)
20491 m_line_has_non_zero_discriminator = m_discriminator != 0;
20494 gdbarch *m_gdbarch;
20496 /* True if we're recording lines.
20497 Otherwise we're building partial symtabs and are just interested in
20498 finding include files mentioned by the line number program. */
20499 bool m_record_lines_p;
20501 /* The line number header. */
20502 line_header *m_line_header;
20504 /* These are part of the standard DWARF line number state machine,
20505 and initialized according to the DWARF spec. */
20507 unsigned char m_op_index = 0;
20508 /* The line table index (1-based) of the current file. */
20509 file_name_index m_file = (file_name_index) 1;
20510 unsigned int m_line = 1;
20512 /* These are initialized in the constructor. */
20514 CORE_ADDR m_address;
20516 unsigned int m_discriminator;
20518 /* Additional bits of state we need to track. */
20520 /* The last file that we called dwarf2_start_subfile for.
20521 This is only used for TLLs. */
20522 unsigned int m_last_file = 0;
20523 /* The last file a line number was recorded for. */
20524 struct subfile *m_last_subfile = NULL;
20526 /* The function to call to record a line. */
20527 record_line_ftype *m_record_line_callback = NULL;
20529 /* The last line number that was recorded, used to coalesce
20530 consecutive entries for the same line. This can happen, for
20531 example, when discriminators are present. PR 17276. */
20532 unsigned int m_last_line = 0;
20533 bool m_line_has_non_zero_discriminator = false;
20537 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20539 CORE_ADDR addr_adj = (((m_op_index + adjust)
20540 / m_line_header->maximum_ops_per_instruction)
20541 * m_line_header->minimum_instruction_length);
20542 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20543 m_op_index = ((m_op_index + adjust)
20544 % m_line_header->maximum_ops_per_instruction);
20548 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20550 unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20551 CORE_ADDR addr_adj = (((m_op_index
20552 + (adj_opcode / m_line_header->line_range))
20553 / m_line_header->maximum_ops_per_instruction)
20554 * m_line_header->minimum_instruction_length);
20555 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20556 m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20557 % m_line_header->maximum_ops_per_instruction);
20559 int line_delta = (m_line_header->line_base
20560 + (adj_opcode % m_line_header->line_range));
20561 advance_line (line_delta);
20562 record_line (false);
20563 m_discriminator = 0;
20567 lnp_state_machine::handle_set_file (file_name_index file)
20571 const file_entry *fe = current_file ();
20573 dwarf2_debug_line_missing_file_complaint ();
20574 else if (m_record_lines_p)
20576 const char *dir = fe->include_dir (m_line_header);
20578 m_last_subfile = current_subfile;
20579 m_line_has_non_zero_discriminator = m_discriminator != 0;
20580 dwarf2_start_subfile (fe->name, dir);
20585 lnp_state_machine::handle_const_add_pc ()
20588 = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20591 = (((m_op_index + adjust)
20592 / m_line_header->maximum_ops_per_instruction)
20593 * m_line_header->minimum_instruction_length);
20595 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20596 m_op_index = ((m_op_index + adjust)
20597 % m_line_header->maximum_ops_per_instruction);
20600 /* Ignore this record_line request. */
20603 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
20608 /* Return non-zero if we should add LINE to the line number table.
20609 LINE is the line to add, LAST_LINE is the last line that was added,
20610 LAST_SUBFILE is the subfile for LAST_LINE.
20611 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20612 had a non-zero discriminator.
20614 We have to be careful in the presence of discriminators.
20615 E.g., for this line:
20617 for (i = 0; i < 100000; i++);
20619 clang can emit four line number entries for that one line,
20620 each with a different discriminator.
20621 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20623 However, we want gdb to coalesce all four entries into one.
20624 Otherwise the user could stepi into the middle of the line and
20625 gdb would get confused about whether the pc really was in the
20626 middle of the line.
20628 Things are further complicated by the fact that two consecutive
20629 line number entries for the same line is a heuristic used by gcc
20630 to denote the end of the prologue. So we can't just discard duplicate
20631 entries, we have to be selective about it. The heuristic we use is
20632 that we only collapse consecutive entries for the same line if at least
20633 one of those entries has a non-zero discriminator. PR 17276.
20635 Note: Addresses in the line number state machine can never go backwards
20636 within one sequence, thus this coalescing is ok. */
20639 dwarf_record_line_p (unsigned int line, unsigned int last_line,
20640 int line_has_non_zero_discriminator,
20641 struct subfile *last_subfile)
20643 if (current_subfile != last_subfile)
20645 if (line != last_line)
20647 /* Same line for the same file that we've seen already.
20648 As a last check, for pr 17276, only record the line if the line
20649 has never had a non-zero discriminator. */
20650 if (!line_has_non_zero_discriminator)
20655 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
20656 in the line table of subfile SUBFILE. */
20659 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20660 unsigned int line, CORE_ADDR address,
20661 record_line_ftype p_record_line)
20663 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20665 if (dwarf_line_debug)
20667 fprintf_unfiltered (gdb_stdlog,
20668 "Recording line %u, file %s, address %s\n",
20669 line, lbasename (subfile->name),
20670 paddress (gdbarch, address));
20673 (*p_record_line) (subfile, line, addr);
20676 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20677 Mark the end of a set of line number records.
20678 The arguments are the same as for dwarf_record_line_1.
20679 If SUBFILE is NULL the request is ignored. */
20682 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20683 CORE_ADDR address, record_line_ftype p_record_line)
20685 if (subfile == NULL)
20688 if (dwarf_line_debug)
20690 fprintf_unfiltered (gdb_stdlog,
20691 "Finishing current line, file %s, address %s\n",
20692 lbasename (subfile->name),
20693 paddress (gdbarch, address));
20696 dwarf_record_line_1 (gdbarch, subfile, 0, address, p_record_line);
20700 lnp_state_machine::record_line (bool end_sequence)
20702 if (dwarf_line_debug)
20704 fprintf_unfiltered (gdb_stdlog,
20705 "Processing actual line %u: file %u,"
20706 " address %s, is_stmt %u, discrim %u\n",
20707 m_line, to_underlying (m_file),
20708 paddress (m_gdbarch, m_address),
20709 m_is_stmt, m_discriminator);
20712 file_entry *fe = current_file ();
20715 dwarf2_debug_line_missing_file_complaint ();
20716 /* For now we ignore lines not starting on an instruction boundary.
20717 But not when processing end_sequence for compatibility with the
20718 previous version of the code. */
20719 else if (m_op_index == 0 || end_sequence)
20721 fe->included_p = 1;
20722 if (m_record_lines_p && m_is_stmt)
20724 if (m_last_subfile != current_subfile || end_sequence)
20726 dwarf_finish_line (m_gdbarch, m_last_subfile,
20727 m_address, m_record_line_callback);
20732 if (dwarf_record_line_p (m_line, m_last_line,
20733 m_line_has_non_zero_discriminator,
20736 dwarf_record_line_1 (m_gdbarch, current_subfile,
20738 m_record_line_callback);
20740 m_last_subfile = current_subfile;
20741 m_last_line = m_line;
20747 lnp_state_machine::lnp_state_machine (gdbarch *arch, line_header *lh,
20748 bool record_lines_p)
20751 m_record_lines_p = record_lines_p;
20752 m_line_header = lh;
20754 m_record_line_callback = ::record_line;
20756 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20757 was a line entry for it so that the backend has a chance to adjust it
20758 and also record it in case it needs it. This is currently used by MIPS
20759 code, cf. `mips_adjust_dwarf2_line'. */
20760 m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20761 m_is_stmt = lh->default_is_stmt;
20762 m_discriminator = 0;
20766 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20767 const gdb_byte *line_ptr,
20768 CORE_ADDR lowpc, CORE_ADDR address)
20770 /* If address < lowpc then it's not a usable value, it's outside the
20771 pc range of the CU. However, we restrict the test to only address
20772 values of zero to preserve GDB's previous behaviour which is to
20773 handle the specific case of a function being GC'd by the linker. */
20775 if (address == 0 && address < lowpc)
20777 /* This line table is for a function which has been
20778 GCd by the linker. Ignore it. PR gdb/12528 */
20780 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20781 long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20783 complaint (&symfile_complaints,
20784 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20785 line_offset, objfile_name (objfile));
20786 m_record_line_callback = noop_record_line;
20787 /* Note: record_line_callback is left as noop_record_line until
20788 we see DW_LNE_end_sequence. */
20792 /* Subroutine of dwarf_decode_lines to simplify it.
20793 Process the line number information in LH.
20794 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20795 program in order to set included_p for every referenced header. */
20798 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20799 const int decode_for_pst_p, CORE_ADDR lowpc)
20801 const gdb_byte *line_ptr, *extended_end;
20802 const gdb_byte *line_end;
20803 unsigned int bytes_read, extended_len;
20804 unsigned char op_code, extended_op;
20805 CORE_ADDR baseaddr;
20806 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20807 bfd *abfd = objfile->obfd;
20808 struct gdbarch *gdbarch = get_objfile_arch (objfile);
20809 /* True if we're recording line info (as opposed to building partial
20810 symtabs and just interested in finding include files mentioned by
20811 the line number program). */
20812 bool record_lines_p = !decode_for_pst_p;
20814 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20816 line_ptr = lh->statement_program_start;
20817 line_end = lh->statement_program_end;
20819 /* Read the statement sequences until there's nothing left. */
20820 while (line_ptr < line_end)
20822 /* The DWARF line number program state machine. Reset the state
20823 machine at the start of each sequence. */
20824 lnp_state_machine state_machine (gdbarch, lh, record_lines_p);
20825 bool end_sequence = false;
20827 if (record_lines_p)
20829 /* Start a subfile for the current file of the state
20831 const file_entry *fe = state_machine.current_file ();
20834 dwarf2_start_subfile (fe->name, fe->include_dir (lh));
20837 /* Decode the table. */
20838 while (line_ptr < line_end && !end_sequence)
20840 op_code = read_1_byte (abfd, line_ptr);
20843 if (op_code >= lh->opcode_base)
20845 /* Special opcode. */
20846 state_machine.handle_special_opcode (op_code);
20848 else switch (op_code)
20850 case DW_LNS_extended_op:
20851 extended_len = read_unsigned_leb128 (abfd, line_ptr,
20853 line_ptr += bytes_read;
20854 extended_end = line_ptr + extended_len;
20855 extended_op = read_1_byte (abfd, line_ptr);
20857 switch (extended_op)
20859 case DW_LNE_end_sequence:
20860 state_machine.handle_end_sequence ();
20861 end_sequence = true;
20863 case DW_LNE_set_address:
20866 = read_address (abfd, line_ptr, cu, &bytes_read);
20867 line_ptr += bytes_read;
20869 state_machine.check_line_address (cu, line_ptr,
20871 state_machine.handle_set_address (baseaddr, address);
20874 case DW_LNE_define_file:
20876 const char *cur_file;
20877 unsigned int mod_time, length;
20880 cur_file = read_direct_string (abfd, line_ptr,
20882 line_ptr += bytes_read;
20883 dindex = (dir_index)
20884 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20885 line_ptr += bytes_read;
20887 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20888 line_ptr += bytes_read;
20890 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20891 line_ptr += bytes_read;
20892 lh->add_file_name (cur_file, dindex, mod_time, length);
20895 case DW_LNE_set_discriminator:
20897 /* The discriminator is not interesting to the
20898 debugger; just ignore it. We still need to
20899 check its value though:
20900 if there are consecutive entries for the same
20901 (non-prologue) line we want to coalesce them.
20904 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20905 line_ptr += bytes_read;
20907 state_machine.handle_set_discriminator (discr);
20911 complaint (&symfile_complaints,
20912 _("mangled .debug_line section"));
20915 /* Make sure that we parsed the extended op correctly. If e.g.
20916 we expected a different address size than the producer used,
20917 we may have read the wrong number of bytes. */
20918 if (line_ptr != extended_end)
20920 complaint (&symfile_complaints,
20921 _("mangled .debug_line section"));
20926 state_machine.handle_copy ();
20928 case DW_LNS_advance_pc:
20931 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20932 line_ptr += bytes_read;
20934 state_machine.handle_advance_pc (adjust);
20937 case DW_LNS_advance_line:
20940 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
20941 line_ptr += bytes_read;
20943 state_machine.handle_advance_line (line_delta);
20946 case DW_LNS_set_file:
20948 file_name_index file
20949 = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
20951 line_ptr += bytes_read;
20953 state_machine.handle_set_file (file);
20956 case DW_LNS_set_column:
20957 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20958 line_ptr += bytes_read;
20960 case DW_LNS_negate_stmt:
20961 state_machine.handle_negate_stmt ();
20963 case DW_LNS_set_basic_block:
20965 /* Add to the address register of the state machine the
20966 address increment value corresponding to special opcode
20967 255. I.e., this value is scaled by the minimum
20968 instruction length since special opcode 255 would have
20969 scaled the increment. */
20970 case DW_LNS_const_add_pc:
20971 state_machine.handle_const_add_pc ();
20973 case DW_LNS_fixed_advance_pc:
20975 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
20978 state_machine.handle_fixed_advance_pc (addr_adj);
20983 /* Unknown standard opcode, ignore it. */
20986 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
20988 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20989 line_ptr += bytes_read;
20996 dwarf2_debug_line_missing_end_sequence_complaint ();
20998 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
20999 in which case we still finish recording the last line). */
21000 state_machine.record_line (true);
21004 /* Decode the Line Number Program (LNP) for the given line_header
21005 structure and CU. The actual information extracted and the type
21006 of structures created from the LNP depends on the value of PST.
21008 1. If PST is NULL, then this procedure uses the data from the program
21009 to create all necessary symbol tables, and their linetables.
21011 2. If PST is not NULL, this procedure reads the program to determine
21012 the list of files included by the unit represented by PST, and
21013 builds all the associated partial symbol tables.
21015 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21016 It is used for relative paths in the line table.
21017 NOTE: When processing partial symtabs (pst != NULL),
21018 comp_dir == pst->dirname.
21020 NOTE: It is important that psymtabs have the same file name (via strcmp)
21021 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21022 symtab we don't use it in the name of the psymtabs we create.
21023 E.g. expand_line_sal requires this when finding psymtabs to expand.
21024 A good testcase for this is mb-inline.exp.
21026 LOWPC is the lowest address in CU (or 0 if not known).
21028 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21029 for its PC<->lines mapping information. Otherwise only the filename
21030 table is read in. */
21033 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21034 struct dwarf2_cu *cu, struct partial_symtab *pst,
21035 CORE_ADDR lowpc, int decode_mapping)
21037 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21038 const int decode_for_pst_p = (pst != NULL);
21040 if (decode_mapping)
21041 dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21043 if (decode_for_pst_p)
21047 /* Now that we're done scanning the Line Header Program, we can
21048 create the psymtab of each included file. */
21049 for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21050 if (lh->file_names[file_index].included_p == 1)
21052 gdb::unique_xmalloc_ptr<char> name_holder;
21053 const char *include_name =
21054 psymtab_include_file_name (lh, file_index, pst, comp_dir,
21056 if (include_name != NULL)
21057 dwarf2_create_include_psymtab (include_name, pst, objfile);
21062 /* Make sure a symtab is created for every file, even files
21063 which contain only variables (i.e. no code with associated
21065 struct compunit_symtab *cust = buildsym_compunit_symtab ();
21068 for (i = 0; i < lh->file_names.size (); i++)
21070 file_entry &fe = lh->file_names[i];
21072 dwarf2_start_subfile (fe.name, fe.include_dir (lh));
21074 if (current_subfile->symtab == NULL)
21076 current_subfile->symtab
21077 = allocate_symtab (cust, current_subfile->name);
21079 fe.symtab = current_subfile->symtab;
21084 /* Start a subfile for DWARF. FILENAME is the name of the file and
21085 DIRNAME the name of the source directory which contains FILENAME
21086 or NULL if not known.
21087 This routine tries to keep line numbers from identical absolute and
21088 relative file names in a common subfile.
21090 Using the `list' example from the GDB testsuite, which resides in
21091 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21092 of /srcdir/list0.c yields the following debugging information for list0.c:
21094 DW_AT_name: /srcdir/list0.c
21095 DW_AT_comp_dir: /compdir
21096 files.files[0].name: list0.h
21097 files.files[0].dir: /srcdir
21098 files.files[1].name: list0.c
21099 files.files[1].dir: /srcdir
21101 The line number information for list0.c has to end up in a single
21102 subfile, so that `break /srcdir/list0.c:1' works as expected.
21103 start_subfile will ensure that this happens provided that we pass the
21104 concatenation of files.files[1].dir and files.files[1].name as the
21108 dwarf2_start_subfile (const char *filename, const char *dirname)
21112 /* In order not to lose the line information directory,
21113 we concatenate it to the filename when it makes sense.
21114 Note that the Dwarf3 standard says (speaking of filenames in line
21115 information): ``The directory index is ignored for file names
21116 that represent full path names''. Thus ignoring dirname in the
21117 `else' branch below isn't an issue. */
21119 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21121 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21125 start_subfile (filename);
21131 /* Start a symtab for DWARF.
21132 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
21134 static struct compunit_symtab *
21135 dwarf2_start_symtab (struct dwarf2_cu *cu,
21136 const char *name, const char *comp_dir, CORE_ADDR low_pc)
21138 struct compunit_symtab *cust
21139 = start_symtab (cu->per_cu->dwarf2_per_objfile->objfile, name, comp_dir,
21140 low_pc, cu->language);
21142 record_debugformat ("DWARF 2");
21143 record_producer (cu->producer);
21145 /* We assume that we're processing GCC output. */
21146 processing_gcc_compilation = 2;
21148 cu->processing_has_namespace_info = 0;
21154 var_decode_location (struct attribute *attr, struct symbol *sym,
21155 struct dwarf2_cu *cu)
21157 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21158 struct comp_unit_head *cu_header = &cu->header;
21160 /* NOTE drow/2003-01-30: There used to be a comment and some special
21161 code here to turn a symbol with DW_AT_external and a
21162 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21163 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21164 with some versions of binutils) where shared libraries could have
21165 relocations against symbols in their debug information - the
21166 minimal symbol would have the right address, but the debug info
21167 would not. It's no longer necessary, because we will explicitly
21168 apply relocations when we read in the debug information now. */
21170 /* A DW_AT_location attribute with no contents indicates that a
21171 variable has been optimized away. */
21172 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21174 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21178 /* Handle one degenerate form of location expression specially, to
21179 preserve GDB's previous behavior when section offsets are
21180 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21181 then mark this symbol as LOC_STATIC. */
21183 if (attr_form_is_block (attr)
21184 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21185 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21186 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21187 && (DW_BLOCK (attr)->size
21188 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21190 unsigned int dummy;
21192 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21193 SYMBOL_VALUE_ADDRESS (sym) =
21194 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21196 SYMBOL_VALUE_ADDRESS (sym) =
21197 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21198 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21199 fixup_symbol_section (sym, objfile);
21200 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21201 SYMBOL_SECTION (sym));
21205 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21206 expression evaluator, and use LOC_COMPUTED only when necessary
21207 (i.e. when the value of a register or memory location is
21208 referenced, or a thread-local block, etc.). Then again, it might
21209 not be worthwhile. I'm assuming that it isn't unless performance
21210 or memory numbers show me otherwise. */
21212 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21214 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21215 cu->has_loclist = 1;
21218 /* Given a pointer to a DWARF information entry, figure out if we need
21219 to make a symbol table entry for it, and if so, create a new entry
21220 and return a pointer to it.
21221 If TYPE is NULL, determine symbol type from the die, otherwise
21222 used the passed type.
21223 If SPACE is not NULL, use it to hold the new symbol. If it is
21224 NULL, allocate a new symbol on the objfile's obstack. */
21226 static struct symbol *
21227 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21228 struct symbol *space)
21230 struct dwarf2_per_objfile *dwarf2_per_objfile
21231 = cu->per_cu->dwarf2_per_objfile;
21232 struct objfile *objfile = dwarf2_per_objfile->objfile;
21233 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21234 struct symbol *sym = NULL;
21236 struct attribute *attr = NULL;
21237 struct attribute *attr2 = NULL;
21238 CORE_ADDR baseaddr;
21239 struct pending **list_to_add = NULL;
21241 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21243 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21245 name = dwarf2_name (die, cu);
21248 const char *linkagename;
21249 int suppress_add = 0;
21254 sym = allocate_symbol (objfile);
21255 OBJSTAT (objfile, n_syms++);
21257 /* Cache this symbol's name and the name's demangled form (if any). */
21258 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21259 linkagename = dwarf2_physname (name, die, cu);
21260 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21262 /* Fortran does not have mangling standard and the mangling does differ
21263 between gfortran, iFort etc. */
21264 if (cu->language == language_fortran
21265 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21266 symbol_set_demangled_name (&(sym->ginfo),
21267 dwarf2_full_name (name, die, cu),
21270 /* Default assumptions.
21271 Use the passed type or decode it from the die. */
21272 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21273 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21275 SYMBOL_TYPE (sym) = type;
21277 SYMBOL_TYPE (sym) = die_type (die, cu);
21278 attr = dwarf2_attr (die,
21279 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21283 SYMBOL_LINE (sym) = DW_UNSND (attr);
21286 attr = dwarf2_attr (die,
21287 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21291 file_name_index file_index = (file_name_index) DW_UNSND (attr);
21292 struct file_entry *fe;
21294 if (cu->line_header != NULL)
21295 fe = cu->line_header->file_name_at (file_index);
21300 complaint (&symfile_complaints,
21301 _("file index out of range"));
21303 symbol_set_symtab (sym, fe->symtab);
21309 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21314 addr = attr_value_as_address (attr);
21315 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21316 SYMBOL_VALUE_ADDRESS (sym) = addr;
21318 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21319 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21320 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21321 add_symbol_to_list (sym, cu->list_in_scope);
21323 case DW_TAG_subprogram:
21324 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21326 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21327 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21328 if ((attr2 && (DW_UNSND (attr2) != 0))
21329 || cu->language == language_ada)
21331 /* Subprograms marked external are stored as a global symbol.
21332 Ada subprograms, whether marked external or not, are always
21333 stored as a global symbol, because we want to be able to
21334 access them globally. For instance, we want to be able
21335 to break on a nested subprogram without having to
21336 specify the context. */
21337 list_to_add = &global_symbols;
21341 list_to_add = cu->list_in_scope;
21344 case DW_TAG_inlined_subroutine:
21345 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21347 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21348 SYMBOL_INLINED (sym) = 1;
21349 list_to_add = cu->list_in_scope;
21351 case DW_TAG_template_value_param:
21353 /* Fall through. */
21354 case DW_TAG_constant:
21355 case DW_TAG_variable:
21356 case DW_TAG_member:
21357 /* Compilation with minimal debug info may result in
21358 variables with missing type entries. Change the
21359 misleading `void' type to something sensible. */
21360 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21361 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21363 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21364 /* In the case of DW_TAG_member, we should only be called for
21365 static const members. */
21366 if (die->tag == DW_TAG_member)
21368 /* dwarf2_add_field uses die_is_declaration,
21369 so we do the same. */
21370 gdb_assert (die_is_declaration (die, cu));
21375 dwarf2_const_value (attr, sym, cu);
21376 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21379 if (attr2 && (DW_UNSND (attr2) != 0))
21380 list_to_add = &global_symbols;
21382 list_to_add = cu->list_in_scope;
21386 attr = dwarf2_attr (die, DW_AT_location, cu);
21389 var_decode_location (attr, sym, cu);
21390 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21392 /* Fortran explicitly imports any global symbols to the local
21393 scope by DW_TAG_common_block. */
21394 if (cu->language == language_fortran && die->parent
21395 && die->parent->tag == DW_TAG_common_block)
21398 if (SYMBOL_CLASS (sym) == LOC_STATIC
21399 && SYMBOL_VALUE_ADDRESS (sym) == 0
21400 && !dwarf2_per_objfile->has_section_at_zero)
21402 /* When a static variable is eliminated by the linker,
21403 the corresponding debug information is not stripped
21404 out, but the variable address is set to null;
21405 do not add such variables into symbol table. */
21407 else if (attr2 && (DW_UNSND (attr2) != 0))
21409 /* Workaround gfortran PR debug/40040 - it uses
21410 DW_AT_location for variables in -fPIC libraries which may
21411 get overriden by other libraries/executable and get
21412 a different address. Resolve it by the minimal symbol
21413 which may come from inferior's executable using copy
21414 relocation. Make this workaround only for gfortran as for
21415 other compilers GDB cannot guess the minimal symbol
21416 Fortran mangling kind. */
21417 if (cu->language == language_fortran && die->parent
21418 && die->parent->tag == DW_TAG_module
21420 && startswith (cu->producer, "GNU Fortran"))
21421 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21423 /* A variable with DW_AT_external is never static,
21424 but it may be block-scoped. */
21425 list_to_add = (cu->list_in_scope == &file_symbols
21426 ? &global_symbols : cu->list_in_scope);
21429 list_to_add = cu->list_in_scope;
21433 /* We do not know the address of this symbol.
21434 If it is an external symbol and we have type information
21435 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21436 The address of the variable will then be determined from
21437 the minimal symbol table whenever the variable is
21439 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21441 /* Fortran explicitly imports any global symbols to the local
21442 scope by DW_TAG_common_block. */
21443 if (cu->language == language_fortran && die->parent
21444 && die->parent->tag == DW_TAG_common_block)
21446 /* SYMBOL_CLASS doesn't matter here because
21447 read_common_block is going to reset it. */
21449 list_to_add = cu->list_in_scope;
21451 else if (attr2 && (DW_UNSND (attr2) != 0)
21452 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21454 /* A variable with DW_AT_external is never static, but it
21455 may be block-scoped. */
21456 list_to_add = (cu->list_in_scope == &file_symbols
21457 ? &global_symbols : cu->list_in_scope);
21459 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21461 else if (!die_is_declaration (die, cu))
21463 /* Use the default LOC_OPTIMIZED_OUT class. */
21464 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21466 list_to_add = cu->list_in_scope;
21470 case DW_TAG_formal_parameter:
21471 /* If we are inside a function, mark this as an argument. If
21472 not, we might be looking at an argument to an inlined function
21473 when we do not have enough information to show inlined frames;
21474 pretend it's a local variable in that case so that the user can
21476 if (context_stack_depth > 0
21477 && context_stack[context_stack_depth - 1].name != NULL)
21478 SYMBOL_IS_ARGUMENT (sym) = 1;
21479 attr = dwarf2_attr (die, DW_AT_location, cu);
21482 var_decode_location (attr, sym, cu);
21484 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21487 dwarf2_const_value (attr, sym, cu);
21490 list_to_add = cu->list_in_scope;
21492 case DW_TAG_unspecified_parameters:
21493 /* From varargs functions; gdb doesn't seem to have any
21494 interest in this information, so just ignore it for now.
21497 case DW_TAG_template_type_param:
21499 /* Fall through. */
21500 case DW_TAG_class_type:
21501 case DW_TAG_interface_type:
21502 case DW_TAG_structure_type:
21503 case DW_TAG_union_type:
21504 case DW_TAG_set_type:
21505 case DW_TAG_enumeration_type:
21506 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21507 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21510 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21511 really ever be static objects: otherwise, if you try
21512 to, say, break of a class's method and you're in a file
21513 which doesn't mention that class, it won't work unless
21514 the check for all static symbols in lookup_symbol_aux
21515 saves you. See the OtherFileClass tests in
21516 gdb.c++/namespace.exp. */
21520 list_to_add = (cu->list_in_scope == &file_symbols
21521 && cu->language == language_cplus
21522 ? &global_symbols : cu->list_in_scope);
21524 /* The semantics of C++ state that "struct foo {
21525 ... }" also defines a typedef for "foo". */
21526 if (cu->language == language_cplus
21527 || cu->language == language_ada
21528 || cu->language == language_d
21529 || cu->language == language_rust)
21531 /* The symbol's name is already allocated along
21532 with this objfile, so we don't need to
21533 duplicate it for the type. */
21534 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21535 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21540 case DW_TAG_typedef:
21541 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21542 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21543 list_to_add = cu->list_in_scope;
21545 case DW_TAG_base_type:
21546 case DW_TAG_subrange_type:
21547 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21548 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21549 list_to_add = cu->list_in_scope;
21551 case DW_TAG_enumerator:
21552 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21555 dwarf2_const_value (attr, sym, cu);
21558 /* NOTE: carlton/2003-11-10: See comment above in the
21559 DW_TAG_class_type, etc. block. */
21561 list_to_add = (cu->list_in_scope == &file_symbols
21562 && cu->language == language_cplus
21563 ? &global_symbols : cu->list_in_scope);
21566 case DW_TAG_imported_declaration:
21567 case DW_TAG_namespace:
21568 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21569 list_to_add = &global_symbols;
21571 case DW_TAG_module:
21572 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21573 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21574 list_to_add = &global_symbols;
21576 case DW_TAG_common_block:
21577 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21578 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21579 add_symbol_to_list (sym, cu->list_in_scope);
21582 /* Not a tag we recognize. Hopefully we aren't processing
21583 trash data, but since we must specifically ignore things
21584 we don't recognize, there is nothing else we should do at
21586 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
21587 dwarf_tag_name (die->tag));
21593 sym->hash_next = objfile->template_symbols;
21594 objfile->template_symbols = sym;
21595 list_to_add = NULL;
21598 if (list_to_add != NULL)
21599 add_symbol_to_list (sym, list_to_add);
21601 /* For the benefit of old versions of GCC, check for anonymous
21602 namespaces based on the demangled name. */
21603 if (!cu->processing_has_namespace_info
21604 && cu->language == language_cplus)
21605 cp_scan_for_anonymous_namespaces (sym, objfile);
21610 /* Given an attr with a DW_FORM_dataN value in host byte order,
21611 zero-extend it as appropriate for the symbol's type. The DWARF
21612 standard (v4) is not entirely clear about the meaning of using
21613 DW_FORM_dataN for a constant with a signed type, where the type is
21614 wider than the data. The conclusion of a discussion on the DWARF
21615 list was that this is unspecified. We choose to always zero-extend
21616 because that is the interpretation long in use by GCC. */
21619 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21620 struct dwarf2_cu *cu, LONGEST *value, int bits)
21622 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21623 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21624 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21625 LONGEST l = DW_UNSND (attr);
21627 if (bits < sizeof (*value) * 8)
21629 l &= ((LONGEST) 1 << bits) - 1;
21632 else if (bits == sizeof (*value) * 8)
21636 gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21637 store_unsigned_integer (bytes, bits / 8, byte_order, l);
21644 /* Read a constant value from an attribute. Either set *VALUE, or if
21645 the value does not fit in *VALUE, set *BYTES - either already
21646 allocated on the objfile obstack, or newly allocated on OBSTACK,
21647 or, set *BATON, if we translated the constant to a location
21651 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21652 const char *name, struct obstack *obstack,
21653 struct dwarf2_cu *cu,
21654 LONGEST *value, const gdb_byte **bytes,
21655 struct dwarf2_locexpr_baton **baton)
21657 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21658 struct comp_unit_head *cu_header = &cu->header;
21659 struct dwarf_block *blk;
21660 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21661 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21667 switch (attr->form)
21670 case DW_FORM_GNU_addr_index:
21674 if (TYPE_LENGTH (type) != cu_header->addr_size)
21675 dwarf2_const_value_length_mismatch_complaint (name,
21676 cu_header->addr_size,
21677 TYPE_LENGTH (type));
21678 /* Symbols of this form are reasonably rare, so we just
21679 piggyback on the existing location code rather than writing
21680 a new implementation of symbol_computed_ops. */
21681 *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21682 (*baton)->per_cu = cu->per_cu;
21683 gdb_assert ((*baton)->per_cu);
21685 (*baton)->size = 2 + cu_header->addr_size;
21686 data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21687 (*baton)->data = data;
21689 data[0] = DW_OP_addr;
21690 store_unsigned_integer (&data[1], cu_header->addr_size,
21691 byte_order, DW_ADDR (attr));
21692 data[cu_header->addr_size + 1] = DW_OP_stack_value;
21695 case DW_FORM_string:
21697 case DW_FORM_GNU_str_index:
21698 case DW_FORM_GNU_strp_alt:
21699 /* DW_STRING is already allocated on the objfile obstack, point
21701 *bytes = (const gdb_byte *) DW_STRING (attr);
21703 case DW_FORM_block1:
21704 case DW_FORM_block2:
21705 case DW_FORM_block4:
21706 case DW_FORM_block:
21707 case DW_FORM_exprloc:
21708 case DW_FORM_data16:
21709 blk = DW_BLOCK (attr);
21710 if (TYPE_LENGTH (type) != blk->size)
21711 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21712 TYPE_LENGTH (type));
21713 *bytes = blk->data;
21716 /* The DW_AT_const_value attributes are supposed to carry the
21717 symbol's value "represented as it would be on the target
21718 architecture." By the time we get here, it's already been
21719 converted to host endianness, so we just need to sign- or
21720 zero-extend it as appropriate. */
21721 case DW_FORM_data1:
21722 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21724 case DW_FORM_data2:
21725 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21727 case DW_FORM_data4:
21728 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21730 case DW_FORM_data8:
21731 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21734 case DW_FORM_sdata:
21735 case DW_FORM_implicit_const:
21736 *value = DW_SND (attr);
21739 case DW_FORM_udata:
21740 *value = DW_UNSND (attr);
21744 complaint (&symfile_complaints,
21745 _("unsupported const value attribute form: '%s'"),
21746 dwarf_form_name (attr->form));
21753 /* Copy constant value from an attribute to a symbol. */
21756 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21757 struct dwarf2_cu *cu)
21759 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21761 const gdb_byte *bytes;
21762 struct dwarf2_locexpr_baton *baton;
21764 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21765 SYMBOL_PRINT_NAME (sym),
21766 &objfile->objfile_obstack, cu,
21767 &value, &bytes, &baton);
21771 SYMBOL_LOCATION_BATON (sym) = baton;
21772 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21774 else if (bytes != NULL)
21776 SYMBOL_VALUE_BYTES (sym) = bytes;
21777 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21781 SYMBOL_VALUE (sym) = value;
21782 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21786 /* Return the type of the die in question using its DW_AT_type attribute. */
21788 static struct type *
21789 die_type (struct die_info *die, struct dwarf2_cu *cu)
21791 struct attribute *type_attr;
21793 type_attr = dwarf2_attr (die, DW_AT_type, cu);
21796 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21797 /* A missing DW_AT_type represents a void type. */
21798 return objfile_type (objfile)->builtin_void;
21801 return lookup_die_type (die, type_attr, cu);
21804 /* True iff CU's producer generates GNAT Ada auxiliary information
21805 that allows to find parallel types through that information instead
21806 of having to do expensive parallel lookups by type name. */
21809 need_gnat_info (struct dwarf2_cu *cu)
21811 /* Assume that the Ada compiler was GNAT, which always produces
21812 the auxiliary information. */
21813 return (cu->language == language_ada);
21816 /* Return the auxiliary type of the die in question using its
21817 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21818 attribute is not present. */
21820 static struct type *
21821 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21823 struct attribute *type_attr;
21825 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21829 return lookup_die_type (die, type_attr, cu);
21832 /* If DIE has a descriptive_type attribute, then set the TYPE's
21833 descriptive type accordingly. */
21836 set_descriptive_type (struct type *type, struct die_info *die,
21837 struct dwarf2_cu *cu)
21839 struct type *descriptive_type = die_descriptive_type (die, cu);
21841 if (descriptive_type)
21843 ALLOCATE_GNAT_AUX_TYPE (type);
21844 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
21848 /* Return the containing type of the die in question using its
21849 DW_AT_containing_type attribute. */
21851 static struct type *
21852 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
21854 struct attribute *type_attr;
21855 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21857 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
21859 error (_("Dwarf Error: Problem turning containing type into gdb type "
21860 "[in module %s]"), objfile_name (objfile));
21862 return lookup_die_type (die, type_attr, cu);
21865 /* Return an error marker type to use for the ill formed type in DIE/CU. */
21867 static struct type *
21868 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
21870 struct dwarf2_per_objfile *dwarf2_per_objfile
21871 = cu->per_cu->dwarf2_per_objfile;
21872 struct objfile *objfile = dwarf2_per_objfile->objfile;
21873 char *message, *saved;
21875 message = xstrprintf (_("<unknown type in %s, CU %s, DIE %s>"),
21876 objfile_name (objfile),
21877 sect_offset_str (cu->header.sect_off),
21878 sect_offset_str (die->sect_off));
21879 saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
21880 message, strlen (message));
21883 return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
21886 /* Look up the type of DIE in CU using its type attribute ATTR.
21887 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
21888 DW_AT_containing_type.
21889 If there is no type substitute an error marker. */
21891 static struct type *
21892 lookup_die_type (struct die_info *die, const struct attribute *attr,
21893 struct dwarf2_cu *cu)
21895 struct dwarf2_per_objfile *dwarf2_per_objfile
21896 = cu->per_cu->dwarf2_per_objfile;
21897 struct objfile *objfile = dwarf2_per_objfile->objfile;
21898 struct type *this_type;
21900 gdb_assert (attr->name == DW_AT_type
21901 || attr->name == DW_AT_GNAT_descriptive_type
21902 || attr->name == DW_AT_containing_type);
21904 /* First see if we have it cached. */
21906 if (attr->form == DW_FORM_GNU_ref_alt)
21908 struct dwarf2_per_cu_data *per_cu;
21909 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
21911 per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
21912 dwarf2_per_objfile);
21913 this_type = get_die_type_at_offset (sect_off, per_cu);
21915 else if (attr_form_is_ref (attr))
21917 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
21919 this_type = get_die_type_at_offset (sect_off, cu->per_cu);
21921 else if (attr->form == DW_FORM_ref_sig8)
21923 ULONGEST signature = DW_SIGNATURE (attr);
21925 return get_signatured_type (die, signature, cu);
21929 complaint (&symfile_complaints,
21930 _("Dwarf Error: Bad type attribute %s in DIE"
21931 " at %s [in module %s]"),
21932 dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
21933 objfile_name (objfile));
21934 return build_error_marker_type (cu, die);
21937 /* If not cached we need to read it in. */
21939 if (this_type == NULL)
21941 struct die_info *type_die = NULL;
21942 struct dwarf2_cu *type_cu = cu;
21944 if (attr_form_is_ref (attr))
21945 type_die = follow_die_ref (die, attr, &type_cu);
21946 if (type_die == NULL)
21947 return build_error_marker_type (cu, die);
21948 /* If we find the type now, it's probably because the type came
21949 from an inter-CU reference and the type's CU got expanded before
21951 this_type = read_type_die (type_die, type_cu);
21954 /* If we still don't have a type use an error marker. */
21956 if (this_type == NULL)
21957 return build_error_marker_type (cu, die);
21962 /* Return the type in DIE, CU.
21963 Returns NULL for invalid types.
21965 This first does a lookup in die_type_hash,
21966 and only reads the die in if necessary.
21968 NOTE: This can be called when reading in partial or full symbols. */
21970 static struct type *
21971 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
21973 struct type *this_type;
21975 this_type = get_die_type (die, cu);
21979 return read_type_die_1 (die, cu);
21982 /* Read the type in DIE, CU.
21983 Returns NULL for invalid types. */
21985 static struct type *
21986 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
21988 struct type *this_type = NULL;
21992 case DW_TAG_class_type:
21993 case DW_TAG_interface_type:
21994 case DW_TAG_structure_type:
21995 case DW_TAG_union_type:
21996 this_type = read_structure_type (die, cu);
21998 case DW_TAG_enumeration_type:
21999 this_type = read_enumeration_type (die, cu);
22001 case DW_TAG_subprogram:
22002 case DW_TAG_subroutine_type:
22003 case DW_TAG_inlined_subroutine:
22004 this_type = read_subroutine_type (die, cu);
22006 case DW_TAG_array_type:
22007 this_type = read_array_type (die, cu);
22009 case DW_TAG_set_type:
22010 this_type = read_set_type (die, cu);
22012 case DW_TAG_pointer_type:
22013 this_type = read_tag_pointer_type (die, cu);
22015 case DW_TAG_ptr_to_member_type:
22016 this_type = read_tag_ptr_to_member_type (die, cu);
22018 case DW_TAG_reference_type:
22019 this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22021 case DW_TAG_rvalue_reference_type:
22022 this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22024 case DW_TAG_const_type:
22025 this_type = read_tag_const_type (die, cu);
22027 case DW_TAG_volatile_type:
22028 this_type = read_tag_volatile_type (die, cu);
22030 case DW_TAG_restrict_type:
22031 this_type = read_tag_restrict_type (die, cu);
22033 case DW_TAG_string_type:
22034 this_type = read_tag_string_type (die, cu);
22036 case DW_TAG_typedef:
22037 this_type = read_typedef (die, cu);
22039 case DW_TAG_subrange_type:
22040 this_type = read_subrange_type (die, cu);
22042 case DW_TAG_base_type:
22043 this_type = read_base_type (die, cu);
22045 case DW_TAG_unspecified_type:
22046 this_type = read_unspecified_type (die, cu);
22048 case DW_TAG_namespace:
22049 this_type = read_namespace_type (die, cu);
22051 case DW_TAG_module:
22052 this_type = read_module_type (die, cu);
22054 case DW_TAG_atomic_type:
22055 this_type = read_tag_atomic_type (die, cu);
22058 complaint (&symfile_complaints,
22059 _("unexpected tag in read_type_die: '%s'"),
22060 dwarf_tag_name (die->tag));
22067 /* See if we can figure out if the class lives in a namespace. We do
22068 this by looking for a member function; its demangled name will
22069 contain namespace info, if there is any.
22070 Return the computed name or NULL.
22071 Space for the result is allocated on the objfile's obstack.
22072 This is the full-die version of guess_partial_die_structure_name.
22073 In this case we know DIE has no useful parent. */
22076 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22078 struct die_info *spec_die;
22079 struct dwarf2_cu *spec_cu;
22080 struct die_info *child;
22081 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22084 spec_die = die_specification (die, &spec_cu);
22085 if (spec_die != NULL)
22091 for (child = die->child;
22093 child = child->sibling)
22095 if (child->tag == DW_TAG_subprogram)
22097 const char *linkage_name = dw2_linkage_name (child, cu);
22099 if (linkage_name != NULL)
22102 = language_class_name_from_physname (cu->language_defn,
22106 if (actual_name != NULL)
22108 const char *die_name = dwarf2_name (die, cu);
22110 if (die_name != NULL
22111 && strcmp (die_name, actual_name) != 0)
22113 /* Strip off the class name from the full name.
22114 We want the prefix. */
22115 int die_name_len = strlen (die_name);
22116 int actual_name_len = strlen (actual_name);
22118 /* Test for '::' as a sanity check. */
22119 if (actual_name_len > die_name_len + 2
22120 && actual_name[actual_name_len
22121 - die_name_len - 1] == ':')
22122 name = (char *) obstack_copy0 (
22123 &objfile->per_bfd->storage_obstack,
22124 actual_name, actual_name_len - die_name_len - 2);
22127 xfree (actual_name);
22136 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22137 prefix part in such case. See
22138 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22140 static const char *
22141 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22143 struct attribute *attr;
22146 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22147 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22150 if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22153 attr = dw2_linkage_name_attr (die, cu);
22154 if (attr == NULL || DW_STRING (attr) == NULL)
22157 /* dwarf2_name had to be already called. */
22158 gdb_assert (DW_STRING_IS_CANONICAL (attr));
22160 /* Strip the base name, keep any leading namespaces/classes. */
22161 base = strrchr (DW_STRING (attr), ':');
22162 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22165 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22166 return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22168 &base[-1] - DW_STRING (attr));
22171 /* Return the name of the namespace/class that DIE is defined within,
22172 or "" if we can't tell. The caller should not xfree the result.
22174 For example, if we're within the method foo() in the following
22184 then determine_prefix on foo's die will return "N::C". */
22186 static const char *
22187 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22189 struct dwarf2_per_objfile *dwarf2_per_objfile
22190 = cu->per_cu->dwarf2_per_objfile;
22191 struct die_info *parent, *spec_die;
22192 struct dwarf2_cu *spec_cu;
22193 struct type *parent_type;
22194 const char *retval;
22196 if (cu->language != language_cplus
22197 && cu->language != language_fortran && cu->language != language_d
22198 && cu->language != language_rust)
22201 retval = anonymous_struct_prefix (die, cu);
22205 /* We have to be careful in the presence of DW_AT_specification.
22206 For example, with GCC 3.4, given the code
22210 // Definition of N::foo.
22214 then we'll have a tree of DIEs like this:
22216 1: DW_TAG_compile_unit
22217 2: DW_TAG_namespace // N
22218 3: DW_TAG_subprogram // declaration of N::foo
22219 4: DW_TAG_subprogram // definition of N::foo
22220 DW_AT_specification // refers to die #3
22222 Thus, when processing die #4, we have to pretend that we're in
22223 the context of its DW_AT_specification, namely the contex of die
22226 spec_die = die_specification (die, &spec_cu);
22227 if (spec_die == NULL)
22228 parent = die->parent;
22231 parent = spec_die->parent;
22235 if (parent == NULL)
22237 else if (parent->building_fullname)
22240 const char *parent_name;
22242 /* It has been seen on RealView 2.2 built binaries,
22243 DW_TAG_template_type_param types actually _defined_ as
22244 children of the parent class:
22247 template class <class Enum> Class{};
22248 Class<enum E> class_e;
22250 1: DW_TAG_class_type (Class)
22251 2: DW_TAG_enumeration_type (E)
22252 3: DW_TAG_enumerator (enum1:0)
22253 3: DW_TAG_enumerator (enum2:1)
22255 2: DW_TAG_template_type_param
22256 DW_AT_type DW_FORM_ref_udata (E)
22258 Besides being broken debug info, it can put GDB into an
22259 infinite loop. Consider:
22261 When we're building the full name for Class<E>, we'll start
22262 at Class, and go look over its template type parameters,
22263 finding E. We'll then try to build the full name of E, and
22264 reach here. We're now trying to build the full name of E,
22265 and look over the parent DIE for containing scope. In the
22266 broken case, if we followed the parent DIE of E, we'd again
22267 find Class, and once again go look at its template type
22268 arguments, etc., etc. Simply don't consider such parent die
22269 as source-level parent of this die (it can't be, the language
22270 doesn't allow it), and break the loop here. */
22271 name = dwarf2_name (die, cu);
22272 parent_name = dwarf2_name (parent, cu);
22273 complaint (&symfile_complaints,
22274 _("template param type '%s' defined within parent '%s'"),
22275 name ? name : "<unknown>",
22276 parent_name ? parent_name : "<unknown>");
22280 switch (parent->tag)
22282 case DW_TAG_namespace:
22283 parent_type = read_type_die (parent, cu);
22284 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22285 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22286 Work around this problem here. */
22287 if (cu->language == language_cplus
22288 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
22290 /* We give a name to even anonymous namespaces. */
22291 return TYPE_TAG_NAME (parent_type);
22292 case DW_TAG_class_type:
22293 case DW_TAG_interface_type:
22294 case DW_TAG_structure_type:
22295 case DW_TAG_union_type:
22296 case DW_TAG_module:
22297 parent_type = read_type_die (parent, cu);
22298 if (TYPE_TAG_NAME (parent_type) != NULL)
22299 return TYPE_TAG_NAME (parent_type);
22301 /* An anonymous structure is only allowed non-static data
22302 members; no typedefs, no member functions, et cetera.
22303 So it does not need a prefix. */
22305 case DW_TAG_compile_unit:
22306 case DW_TAG_partial_unit:
22307 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22308 if (cu->language == language_cplus
22309 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22310 && die->child != NULL
22311 && (die->tag == DW_TAG_class_type
22312 || die->tag == DW_TAG_structure_type
22313 || die->tag == DW_TAG_union_type))
22315 char *name = guess_full_die_structure_name (die, cu);
22320 case DW_TAG_enumeration_type:
22321 parent_type = read_type_die (parent, cu);
22322 if (TYPE_DECLARED_CLASS (parent_type))
22324 if (TYPE_TAG_NAME (parent_type) != NULL)
22325 return TYPE_TAG_NAME (parent_type);
22328 /* Fall through. */
22330 return determine_prefix (parent, cu);
22334 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22335 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22336 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22337 an obconcat, otherwise allocate storage for the result. The CU argument is
22338 used to determine the language and hence, the appropriate separator. */
22340 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22343 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22344 int physname, struct dwarf2_cu *cu)
22346 const char *lead = "";
22349 if (suffix == NULL || suffix[0] == '\0'
22350 || prefix == NULL || prefix[0] == '\0')
22352 else if (cu->language == language_d)
22354 /* For D, the 'main' function could be defined in any module, but it
22355 should never be prefixed. */
22356 if (strcmp (suffix, "D main") == 0)
22364 else if (cu->language == language_fortran && physname)
22366 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22367 DW_AT_MIPS_linkage_name is preferred and used instead. */
22375 if (prefix == NULL)
22377 if (suffix == NULL)
22384 xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22386 strcpy (retval, lead);
22387 strcat (retval, prefix);
22388 strcat (retval, sep);
22389 strcat (retval, suffix);
22394 /* We have an obstack. */
22395 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22399 /* Return sibling of die, NULL if no sibling. */
22401 static struct die_info *
22402 sibling_die (struct die_info *die)
22404 return die->sibling;
22407 /* Get name of a die, return NULL if not found. */
22409 static const char *
22410 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22411 struct obstack *obstack)
22413 if (name && cu->language == language_cplus)
22415 std::string canon_name = cp_canonicalize_string (name);
22417 if (!canon_name.empty ())
22419 if (canon_name != name)
22420 name = (const char *) obstack_copy0 (obstack,
22421 canon_name.c_str (),
22422 canon_name.length ());
22429 /* Get name of a die, return NULL if not found.
22430 Anonymous namespaces are converted to their magic string. */
22432 static const char *
22433 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22435 struct attribute *attr;
22436 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22438 attr = dwarf2_attr (die, DW_AT_name, cu);
22439 if ((!attr || !DW_STRING (attr))
22440 && die->tag != DW_TAG_namespace
22441 && die->tag != DW_TAG_class_type
22442 && die->tag != DW_TAG_interface_type
22443 && die->tag != DW_TAG_structure_type
22444 && die->tag != DW_TAG_union_type)
22449 case DW_TAG_compile_unit:
22450 case DW_TAG_partial_unit:
22451 /* Compilation units have a DW_AT_name that is a filename, not
22452 a source language identifier. */
22453 case DW_TAG_enumeration_type:
22454 case DW_TAG_enumerator:
22455 /* These tags always have simple identifiers already; no need
22456 to canonicalize them. */
22457 return DW_STRING (attr);
22459 case DW_TAG_namespace:
22460 if (attr != NULL && DW_STRING (attr) != NULL)
22461 return DW_STRING (attr);
22462 return CP_ANONYMOUS_NAMESPACE_STR;
22464 case DW_TAG_class_type:
22465 case DW_TAG_interface_type:
22466 case DW_TAG_structure_type:
22467 case DW_TAG_union_type:
22468 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22469 structures or unions. These were of the form "._%d" in GCC 4.1,
22470 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22471 and GCC 4.4. We work around this problem by ignoring these. */
22472 if (attr && DW_STRING (attr)
22473 && (startswith (DW_STRING (attr), "._")
22474 || startswith (DW_STRING (attr), "<anonymous")))
22477 /* GCC might emit a nameless typedef that has a linkage name. See
22478 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22479 if (!attr || DW_STRING (attr) == NULL)
22481 char *demangled = NULL;
22483 attr = dw2_linkage_name_attr (die, cu);
22484 if (attr == NULL || DW_STRING (attr) == NULL)
22487 /* Avoid demangling DW_STRING (attr) the second time on a second
22488 call for the same DIE. */
22489 if (!DW_STRING_IS_CANONICAL (attr))
22490 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22496 /* FIXME: we already did this for the partial symbol... */
22499 obstack_copy0 (&objfile->per_bfd->storage_obstack,
22500 demangled, strlen (demangled)));
22501 DW_STRING_IS_CANONICAL (attr) = 1;
22504 /* Strip any leading namespaces/classes, keep only the base name.
22505 DW_AT_name for named DIEs does not contain the prefixes. */
22506 base = strrchr (DW_STRING (attr), ':');
22507 if (base && base > DW_STRING (attr) && base[-1] == ':')
22510 return DW_STRING (attr);
22519 if (!DW_STRING_IS_CANONICAL (attr))
22522 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22523 &objfile->per_bfd->storage_obstack);
22524 DW_STRING_IS_CANONICAL (attr) = 1;
22526 return DW_STRING (attr);
22529 /* Return the die that this die in an extension of, or NULL if there
22530 is none. *EXT_CU is the CU containing DIE on input, and the CU
22531 containing the return value on output. */
22533 static struct die_info *
22534 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22536 struct attribute *attr;
22538 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22542 return follow_die_ref (die, attr, ext_cu);
22545 /* Convert a DIE tag into its string name. */
22547 static const char *
22548 dwarf_tag_name (unsigned tag)
22550 const char *name = get_DW_TAG_name (tag);
22553 return "DW_TAG_<unknown>";
22558 /* Convert a DWARF attribute code into its string name. */
22560 static const char *
22561 dwarf_attr_name (unsigned attr)
22565 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22566 if (attr == DW_AT_MIPS_fde)
22567 return "DW_AT_MIPS_fde";
22569 if (attr == DW_AT_HP_block_index)
22570 return "DW_AT_HP_block_index";
22573 name = get_DW_AT_name (attr);
22576 return "DW_AT_<unknown>";
22581 /* Convert a DWARF value form code into its string name. */
22583 static const char *
22584 dwarf_form_name (unsigned form)
22586 const char *name = get_DW_FORM_name (form);
22589 return "DW_FORM_<unknown>";
22594 static const char *
22595 dwarf_bool_name (unsigned mybool)
22603 /* Convert a DWARF type code into its string name. */
22605 static const char *
22606 dwarf_type_encoding_name (unsigned enc)
22608 const char *name = get_DW_ATE_name (enc);
22611 return "DW_ATE_<unknown>";
22617 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22621 print_spaces (indent, f);
22622 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22623 dwarf_tag_name (die->tag), die->abbrev,
22624 sect_offset_str (die->sect_off));
22626 if (die->parent != NULL)
22628 print_spaces (indent, f);
22629 fprintf_unfiltered (f, " parent at offset: %s\n",
22630 sect_offset_str (die->parent->sect_off));
22633 print_spaces (indent, f);
22634 fprintf_unfiltered (f, " has children: %s\n",
22635 dwarf_bool_name (die->child != NULL));
22637 print_spaces (indent, f);
22638 fprintf_unfiltered (f, " attributes:\n");
22640 for (i = 0; i < die->num_attrs; ++i)
22642 print_spaces (indent, f);
22643 fprintf_unfiltered (f, " %s (%s) ",
22644 dwarf_attr_name (die->attrs[i].name),
22645 dwarf_form_name (die->attrs[i].form));
22647 switch (die->attrs[i].form)
22650 case DW_FORM_GNU_addr_index:
22651 fprintf_unfiltered (f, "address: ");
22652 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22654 case DW_FORM_block2:
22655 case DW_FORM_block4:
22656 case DW_FORM_block:
22657 case DW_FORM_block1:
22658 fprintf_unfiltered (f, "block: size %s",
22659 pulongest (DW_BLOCK (&die->attrs[i])->size));
22661 case DW_FORM_exprloc:
22662 fprintf_unfiltered (f, "expression: size %s",
22663 pulongest (DW_BLOCK (&die->attrs[i])->size));
22665 case DW_FORM_data16:
22666 fprintf_unfiltered (f, "constant of 16 bytes");
22668 case DW_FORM_ref_addr:
22669 fprintf_unfiltered (f, "ref address: ");
22670 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22672 case DW_FORM_GNU_ref_alt:
22673 fprintf_unfiltered (f, "alt ref address: ");
22674 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22680 case DW_FORM_ref_udata:
22681 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22682 (long) (DW_UNSND (&die->attrs[i])));
22684 case DW_FORM_data1:
22685 case DW_FORM_data2:
22686 case DW_FORM_data4:
22687 case DW_FORM_data8:
22688 case DW_FORM_udata:
22689 case DW_FORM_sdata:
22690 fprintf_unfiltered (f, "constant: %s",
22691 pulongest (DW_UNSND (&die->attrs[i])));
22693 case DW_FORM_sec_offset:
22694 fprintf_unfiltered (f, "section offset: %s",
22695 pulongest (DW_UNSND (&die->attrs[i])));
22697 case DW_FORM_ref_sig8:
22698 fprintf_unfiltered (f, "signature: %s",
22699 hex_string (DW_SIGNATURE (&die->attrs[i])));
22701 case DW_FORM_string:
22703 case DW_FORM_line_strp:
22704 case DW_FORM_GNU_str_index:
22705 case DW_FORM_GNU_strp_alt:
22706 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22707 DW_STRING (&die->attrs[i])
22708 ? DW_STRING (&die->attrs[i]) : "",
22709 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22712 if (DW_UNSND (&die->attrs[i]))
22713 fprintf_unfiltered (f, "flag: TRUE");
22715 fprintf_unfiltered (f, "flag: FALSE");
22717 case DW_FORM_flag_present:
22718 fprintf_unfiltered (f, "flag: TRUE");
22720 case DW_FORM_indirect:
22721 /* The reader will have reduced the indirect form to
22722 the "base form" so this form should not occur. */
22723 fprintf_unfiltered (f,
22724 "unexpected attribute form: DW_FORM_indirect");
22726 case DW_FORM_implicit_const:
22727 fprintf_unfiltered (f, "constant: %s",
22728 plongest (DW_SND (&die->attrs[i])));
22731 fprintf_unfiltered (f, "unsupported attribute form: %d.",
22732 die->attrs[i].form);
22735 fprintf_unfiltered (f, "\n");
22740 dump_die_for_error (struct die_info *die)
22742 dump_die_shallow (gdb_stderr, 0, die);
22746 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22748 int indent = level * 4;
22750 gdb_assert (die != NULL);
22752 if (level >= max_level)
22755 dump_die_shallow (f, indent, die);
22757 if (die->child != NULL)
22759 print_spaces (indent, f);
22760 fprintf_unfiltered (f, " Children:");
22761 if (level + 1 < max_level)
22763 fprintf_unfiltered (f, "\n");
22764 dump_die_1 (f, level + 1, max_level, die->child);
22768 fprintf_unfiltered (f,
22769 " [not printed, max nesting level reached]\n");
22773 if (die->sibling != NULL && level > 0)
22775 dump_die_1 (f, level, max_level, die->sibling);
22779 /* This is called from the pdie macro in gdbinit.in.
22780 It's not static so gcc will keep a copy callable from gdb. */
22783 dump_die (struct die_info *die, int max_level)
22785 dump_die_1 (gdb_stdlog, 0, max_level, die);
22789 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22793 slot = htab_find_slot_with_hash (cu->die_hash, die,
22794 to_underlying (die->sect_off),
22800 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22804 dwarf2_get_ref_die_offset (const struct attribute *attr)
22806 if (attr_form_is_ref (attr))
22807 return (sect_offset) DW_UNSND (attr);
22809 complaint (&symfile_complaints,
22810 _("unsupported die ref attribute form: '%s'"),
22811 dwarf_form_name (attr->form));
22815 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22816 * the value held by the attribute is not constant. */
22819 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22821 if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22822 return DW_SND (attr);
22823 else if (attr->form == DW_FORM_udata
22824 || attr->form == DW_FORM_data1
22825 || attr->form == DW_FORM_data2
22826 || attr->form == DW_FORM_data4
22827 || attr->form == DW_FORM_data8)
22828 return DW_UNSND (attr);
22831 /* For DW_FORM_data16 see attr_form_is_constant. */
22832 complaint (&symfile_complaints,
22833 _("Attribute value is not a constant (%s)"),
22834 dwarf_form_name (attr->form));
22835 return default_value;
22839 /* Follow reference or signature attribute ATTR of SRC_DIE.
22840 On entry *REF_CU is the CU of SRC_DIE.
22841 On exit *REF_CU is the CU of the result. */
22843 static struct die_info *
22844 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
22845 struct dwarf2_cu **ref_cu)
22847 struct die_info *die;
22849 if (attr_form_is_ref (attr))
22850 die = follow_die_ref (src_die, attr, ref_cu);
22851 else if (attr->form == DW_FORM_ref_sig8)
22852 die = follow_die_sig (src_die, attr, ref_cu);
22855 dump_die_for_error (src_die);
22856 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22857 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
22863 /* Follow reference OFFSET.
22864 On entry *REF_CU is the CU of the source die referencing OFFSET.
22865 On exit *REF_CU is the CU of the result.
22866 Returns NULL if OFFSET is invalid. */
22868 static struct die_info *
22869 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
22870 struct dwarf2_cu **ref_cu)
22872 struct die_info temp_die;
22873 struct dwarf2_cu *target_cu, *cu = *ref_cu;
22874 struct dwarf2_per_objfile *dwarf2_per_objfile
22875 = cu->per_cu->dwarf2_per_objfile;
22877 gdb_assert (cu->per_cu != NULL);
22881 if (cu->per_cu->is_debug_types)
22883 /* .debug_types CUs cannot reference anything outside their CU.
22884 If they need to, they have to reference a signatured type via
22885 DW_FORM_ref_sig8. */
22886 if (!offset_in_cu_p (&cu->header, sect_off))
22889 else if (offset_in_dwz != cu->per_cu->is_dwz
22890 || !offset_in_cu_p (&cu->header, sect_off))
22892 struct dwarf2_per_cu_data *per_cu;
22894 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
22895 dwarf2_per_objfile);
22897 /* If necessary, add it to the queue and load its DIEs. */
22898 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
22899 load_full_comp_unit (per_cu, false, cu->language);
22901 target_cu = per_cu->cu;
22903 else if (cu->dies == NULL)
22905 /* We're loading full DIEs during partial symbol reading. */
22906 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
22907 load_full_comp_unit (cu->per_cu, false, language_minimal);
22910 *ref_cu = target_cu;
22911 temp_die.sect_off = sect_off;
22912 return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
22914 to_underlying (sect_off));
22917 /* Follow reference attribute ATTR of SRC_DIE.
22918 On entry *REF_CU is the CU of SRC_DIE.
22919 On exit *REF_CU is the CU of the result. */
22921 static struct die_info *
22922 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
22923 struct dwarf2_cu **ref_cu)
22925 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22926 struct dwarf2_cu *cu = *ref_cu;
22927 struct die_info *die;
22929 die = follow_die_offset (sect_off,
22930 (attr->form == DW_FORM_GNU_ref_alt
22931 || cu->per_cu->is_dwz),
22934 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
22935 "at %s [in module %s]"),
22936 sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
22937 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
22942 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
22943 Returned value is intended for DW_OP_call*. Returned
22944 dwarf2_locexpr_baton->data has lifetime of
22945 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
22947 struct dwarf2_locexpr_baton
22948 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
22949 struct dwarf2_per_cu_data *per_cu,
22950 CORE_ADDR (*get_frame_pc) (void *baton),
22953 struct dwarf2_cu *cu;
22954 struct die_info *die;
22955 struct attribute *attr;
22956 struct dwarf2_locexpr_baton retval;
22957 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
22958 struct objfile *objfile = dwarf2_per_objfile->objfile;
22960 if (per_cu->cu == NULL)
22961 load_cu (per_cu, false);
22965 /* We shouldn't get here for a dummy CU, but don't crash on the user.
22966 Instead just throw an error, not much else we can do. */
22967 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
22968 sect_offset_str (sect_off), objfile_name (objfile));
22971 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
22973 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
22974 sect_offset_str (sect_off), objfile_name (objfile));
22976 attr = dwarf2_attr (die, DW_AT_location, cu);
22979 /* DWARF: "If there is no such attribute, then there is no effect.".
22980 DATA is ignored if SIZE is 0. */
22982 retval.data = NULL;
22985 else if (attr_form_is_section_offset (attr))
22987 struct dwarf2_loclist_baton loclist_baton;
22988 CORE_ADDR pc = (*get_frame_pc) (baton);
22991 fill_in_loclist_baton (cu, &loclist_baton, attr);
22993 retval.data = dwarf2_find_location_expression (&loclist_baton,
22995 retval.size = size;
22999 if (!attr_form_is_block (attr))
23000 error (_("Dwarf Error: DIE at %s referenced in module %s "
23001 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23002 sect_offset_str (sect_off), objfile_name (objfile));
23004 retval.data = DW_BLOCK (attr)->data;
23005 retval.size = DW_BLOCK (attr)->size;
23007 retval.per_cu = cu->per_cu;
23009 age_cached_comp_units (dwarf2_per_objfile);
23014 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23017 struct dwarf2_locexpr_baton
23018 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23019 struct dwarf2_per_cu_data *per_cu,
23020 CORE_ADDR (*get_frame_pc) (void *baton),
23023 sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23025 return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23028 /* Write a constant of a given type as target-ordered bytes into
23031 static const gdb_byte *
23032 write_constant_as_bytes (struct obstack *obstack,
23033 enum bfd_endian byte_order,
23040 *len = TYPE_LENGTH (type);
23041 result = (gdb_byte *) obstack_alloc (obstack, *len);
23042 store_unsigned_integer (result, *len, byte_order, value);
23047 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23048 pointer to the constant bytes and set LEN to the length of the
23049 data. If memory is needed, allocate it on OBSTACK. If the DIE
23050 does not have a DW_AT_const_value, return NULL. */
23053 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23054 struct dwarf2_per_cu_data *per_cu,
23055 struct obstack *obstack,
23058 struct dwarf2_cu *cu;
23059 struct die_info *die;
23060 struct attribute *attr;
23061 const gdb_byte *result = NULL;
23064 enum bfd_endian byte_order;
23065 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23067 if (per_cu->cu == NULL)
23068 load_cu (per_cu, false);
23072 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23073 Instead just throw an error, not much else we can do. */
23074 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23075 sect_offset_str (sect_off), objfile_name (objfile));
23078 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23080 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23081 sect_offset_str (sect_off), objfile_name (objfile));
23083 attr = dwarf2_attr (die, DW_AT_const_value, cu);
23087 byte_order = (bfd_big_endian (objfile->obfd)
23088 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23090 switch (attr->form)
23093 case DW_FORM_GNU_addr_index:
23097 *len = cu->header.addr_size;
23098 tem = (gdb_byte *) obstack_alloc (obstack, *len);
23099 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23103 case DW_FORM_string:
23105 case DW_FORM_GNU_str_index:
23106 case DW_FORM_GNU_strp_alt:
23107 /* DW_STRING is already allocated on the objfile obstack, point
23109 result = (const gdb_byte *) DW_STRING (attr);
23110 *len = strlen (DW_STRING (attr));
23112 case DW_FORM_block1:
23113 case DW_FORM_block2:
23114 case DW_FORM_block4:
23115 case DW_FORM_block:
23116 case DW_FORM_exprloc:
23117 case DW_FORM_data16:
23118 result = DW_BLOCK (attr)->data;
23119 *len = DW_BLOCK (attr)->size;
23122 /* The DW_AT_const_value attributes are supposed to carry the
23123 symbol's value "represented as it would be on the target
23124 architecture." By the time we get here, it's already been
23125 converted to host endianness, so we just need to sign- or
23126 zero-extend it as appropriate. */
23127 case DW_FORM_data1:
23128 type = die_type (die, cu);
23129 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23130 if (result == NULL)
23131 result = write_constant_as_bytes (obstack, byte_order,
23134 case DW_FORM_data2:
23135 type = die_type (die, cu);
23136 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23137 if (result == NULL)
23138 result = write_constant_as_bytes (obstack, byte_order,
23141 case DW_FORM_data4:
23142 type = die_type (die, cu);
23143 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23144 if (result == NULL)
23145 result = write_constant_as_bytes (obstack, byte_order,
23148 case DW_FORM_data8:
23149 type = die_type (die, cu);
23150 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23151 if (result == NULL)
23152 result = write_constant_as_bytes (obstack, byte_order,
23156 case DW_FORM_sdata:
23157 case DW_FORM_implicit_const:
23158 type = die_type (die, cu);
23159 result = write_constant_as_bytes (obstack, byte_order,
23160 type, DW_SND (attr), len);
23163 case DW_FORM_udata:
23164 type = die_type (die, cu);
23165 result = write_constant_as_bytes (obstack, byte_order,
23166 type, DW_UNSND (attr), len);
23170 complaint (&symfile_complaints,
23171 _("unsupported const value attribute form: '%s'"),
23172 dwarf_form_name (attr->form));
23179 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23180 valid type for this die is found. */
23183 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23184 struct dwarf2_per_cu_data *per_cu)
23186 struct dwarf2_cu *cu;
23187 struct die_info *die;
23189 if (per_cu->cu == NULL)
23190 load_cu (per_cu, false);
23195 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23199 return die_type (die, cu);
23202 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23206 dwarf2_get_die_type (cu_offset die_offset,
23207 struct dwarf2_per_cu_data *per_cu)
23209 sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23210 return get_die_type_at_offset (die_offset_sect, per_cu);
23213 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23214 On entry *REF_CU is the CU of SRC_DIE.
23215 On exit *REF_CU is the CU of the result.
23216 Returns NULL if the referenced DIE isn't found. */
23218 static struct die_info *
23219 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23220 struct dwarf2_cu **ref_cu)
23222 struct die_info temp_die;
23223 struct dwarf2_cu *sig_cu;
23224 struct die_info *die;
23226 /* While it might be nice to assert sig_type->type == NULL here,
23227 we can get here for DW_AT_imported_declaration where we need
23228 the DIE not the type. */
23230 /* If necessary, add it to the queue and load its DIEs. */
23232 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23233 read_signatured_type (sig_type);
23235 sig_cu = sig_type->per_cu.cu;
23236 gdb_assert (sig_cu != NULL);
23237 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23238 temp_die.sect_off = sig_type->type_offset_in_section;
23239 die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23240 to_underlying (temp_die.sect_off));
23243 struct dwarf2_per_objfile *dwarf2_per_objfile
23244 = (*ref_cu)->per_cu->dwarf2_per_objfile;
23246 /* For .gdb_index version 7 keep track of included TUs.
23247 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23248 if (dwarf2_per_objfile->index_table != NULL
23249 && dwarf2_per_objfile->index_table->version <= 7)
23251 VEC_safe_push (dwarf2_per_cu_ptr,
23252 (*ref_cu)->per_cu->imported_symtabs,
23263 /* Follow signatured type referenced by ATTR in SRC_DIE.
23264 On entry *REF_CU is the CU of SRC_DIE.
23265 On exit *REF_CU is the CU of the result.
23266 The result is the DIE of the type.
23267 If the referenced type cannot be found an error is thrown. */
23269 static struct die_info *
23270 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23271 struct dwarf2_cu **ref_cu)
23273 ULONGEST signature = DW_SIGNATURE (attr);
23274 struct signatured_type *sig_type;
23275 struct die_info *die;
23277 gdb_assert (attr->form == DW_FORM_ref_sig8);
23279 sig_type = lookup_signatured_type (*ref_cu, signature);
23280 /* sig_type will be NULL if the signatured type is missing from
23282 if (sig_type == NULL)
23284 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23285 " from DIE at %s [in module %s]"),
23286 hex_string (signature), sect_offset_str (src_die->sect_off),
23287 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23290 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23293 dump_die_for_error (src_die);
23294 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23295 " from DIE at %s [in module %s]"),
23296 hex_string (signature), sect_offset_str (src_die->sect_off),
23297 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23303 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23304 reading in and processing the type unit if necessary. */
23306 static struct type *
23307 get_signatured_type (struct die_info *die, ULONGEST signature,
23308 struct dwarf2_cu *cu)
23310 struct dwarf2_per_objfile *dwarf2_per_objfile
23311 = cu->per_cu->dwarf2_per_objfile;
23312 struct signatured_type *sig_type;
23313 struct dwarf2_cu *type_cu;
23314 struct die_info *type_die;
23317 sig_type = lookup_signatured_type (cu, signature);
23318 /* sig_type will be NULL if the signatured type is missing from
23320 if (sig_type == NULL)
23322 complaint (&symfile_complaints,
23323 _("Dwarf Error: Cannot find signatured DIE %s referenced"
23324 " from DIE at %s [in module %s]"),
23325 hex_string (signature), sect_offset_str (die->sect_off),
23326 objfile_name (dwarf2_per_objfile->objfile));
23327 return build_error_marker_type (cu, die);
23330 /* If we already know the type we're done. */
23331 if (sig_type->type != NULL)
23332 return sig_type->type;
23335 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23336 if (type_die != NULL)
23338 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23339 is created. This is important, for example, because for c++ classes
23340 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23341 type = read_type_die (type_die, type_cu);
23344 complaint (&symfile_complaints,
23345 _("Dwarf Error: Cannot build signatured type %s"
23346 " referenced from DIE at %s [in module %s]"),
23347 hex_string (signature), sect_offset_str (die->sect_off),
23348 objfile_name (dwarf2_per_objfile->objfile));
23349 type = build_error_marker_type (cu, die);
23354 complaint (&symfile_complaints,
23355 _("Dwarf Error: Problem reading signatured DIE %s referenced"
23356 " from DIE at %s [in module %s]"),
23357 hex_string (signature), sect_offset_str (die->sect_off),
23358 objfile_name (dwarf2_per_objfile->objfile));
23359 type = build_error_marker_type (cu, die);
23361 sig_type->type = type;
23366 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23367 reading in and processing the type unit if necessary. */
23369 static struct type *
23370 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23371 struct dwarf2_cu *cu) /* ARI: editCase function */
23373 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23374 if (attr_form_is_ref (attr))
23376 struct dwarf2_cu *type_cu = cu;
23377 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23379 return read_type_die (type_die, type_cu);
23381 else if (attr->form == DW_FORM_ref_sig8)
23383 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23387 struct dwarf2_per_objfile *dwarf2_per_objfile
23388 = cu->per_cu->dwarf2_per_objfile;
23390 complaint (&symfile_complaints,
23391 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23392 " at %s [in module %s]"),
23393 dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23394 objfile_name (dwarf2_per_objfile->objfile));
23395 return build_error_marker_type (cu, die);
23399 /* Load the DIEs associated with type unit PER_CU into memory. */
23402 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23404 struct signatured_type *sig_type;
23406 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23407 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23409 /* We have the per_cu, but we need the signatured_type.
23410 Fortunately this is an easy translation. */
23411 gdb_assert (per_cu->is_debug_types);
23412 sig_type = (struct signatured_type *) per_cu;
23414 gdb_assert (per_cu->cu == NULL);
23416 read_signatured_type (sig_type);
23418 gdb_assert (per_cu->cu != NULL);
23421 /* die_reader_func for read_signatured_type.
23422 This is identical to load_full_comp_unit_reader,
23423 but is kept separate for now. */
23426 read_signatured_type_reader (const struct die_reader_specs *reader,
23427 const gdb_byte *info_ptr,
23428 struct die_info *comp_unit_die,
23432 struct dwarf2_cu *cu = reader->cu;
23434 gdb_assert (cu->die_hash == NULL);
23436 htab_create_alloc_ex (cu->header.length / 12,
23440 &cu->comp_unit_obstack,
23441 hashtab_obstack_allocate,
23442 dummy_obstack_deallocate);
23445 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23446 &info_ptr, comp_unit_die);
23447 cu->dies = comp_unit_die;
23448 /* comp_unit_die is not stored in die_hash, no need. */
23450 /* We try not to read any attributes in this function, because not
23451 all CUs needed for references have been loaded yet, and symbol
23452 table processing isn't initialized. But we have to set the CU language,
23453 or we won't be able to build types correctly.
23454 Similarly, if we do not read the producer, we can not apply
23455 producer-specific interpretation. */
23456 prepare_one_comp_unit (cu, cu->dies, language_minimal);
23459 /* Read in a signatured type and build its CU and DIEs.
23460 If the type is a stub for the real type in a DWO file,
23461 read in the real type from the DWO file as well. */
23464 read_signatured_type (struct signatured_type *sig_type)
23466 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23468 gdb_assert (per_cu->is_debug_types);
23469 gdb_assert (per_cu->cu == NULL);
23471 init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23472 read_signatured_type_reader, NULL);
23473 sig_type->per_cu.tu_read = 1;
23476 /* Decode simple location descriptions.
23477 Given a pointer to a dwarf block that defines a location, compute
23478 the location and return the value.
23480 NOTE drow/2003-11-18: This function is called in two situations
23481 now: for the address of static or global variables (partial symbols
23482 only) and for offsets into structures which are expected to be
23483 (more or less) constant. The partial symbol case should go away,
23484 and only the constant case should remain. That will let this
23485 function complain more accurately. A few special modes are allowed
23486 without complaint for global variables (for instance, global
23487 register values and thread-local values).
23489 A location description containing no operations indicates that the
23490 object is optimized out. The return value is 0 for that case.
23491 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23492 callers will only want a very basic result and this can become a
23495 Note that stack[0] is unused except as a default error return. */
23498 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23500 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23502 size_t size = blk->size;
23503 const gdb_byte *data = blk->data;
23504 CORE_ADDR stack[64];
23506 unsigned int bytes_read, unsnd;
23512 stack[++stacki] = 0;
23551 stack[++stacki] = op - DW_OP_lit0;
23586 stack[++stacki] = op - DW_OP_reg0;
23588 dwarf2_complex_location_expr_complaint ();
23592 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23594 stack[++stacki] = unsnd;
23596 dwarf2_complex_location_expr_complaint ();
23600 stack[++stacki] = read_address (objfile->obfd, &data[i],
23605 case DW_OP_const1u:
23606 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23610 case DW_OP_const1s:
23611 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23615 case DW_OP_const2u:
23616 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23620 case DW_OP_const2s:
23621 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23625 case DW_OP_const4u:
23626 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23630 case DW_OP_const4s:
23631 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23635 case DW_OP_const8u:
23636 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23641 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23647 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23652 stack[stacki + 1] = stack[stacki];
23657 stack[stacki - 1] += stack[stacki];
23661 case DW_OP_plus_uconst:
23662 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23668 stack[stacki - 1] -= stack[stacki];
23673 /* If we're not the last op, then we definitely can't encode
23674 this using GDB's address_class enum. This is valid for partial
23675 global symbols, although the variable's address will be bogus
23678 dwarf2_complex_location_expr_complaint ();
23681 case DW_OP_GNU_push_tls_address:
23682 case DW_OP_form_tls_address:
23683 /* The top of the stack has the offset from the beginning
23684 of the thread control block at which the variable is located. */
23685 /* Nothing should follow this operator, so the top of stack would
23687 /* This is valid for partial global symbols, but the variable's
23688 address will be bogus in the psymtab. Make it always at least
23689 non-zero to not look as a variable garbage collected by linker
23690 which have DW_OP_addr 0. */
23692 dwarf2_complex_location_expr_complaint ();
23696 case DW_OP_GNU_uninit:
23699 case DW_OP_GNU_addr_index:
23700 case DW_OP_GNU_const_index:
23701 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23708 const char *name = get_DW_OP_name (op);
23711 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
23714 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
23718 return (stack[stacki]);
23721 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23722 outside of the allocated space. Also enforce minimum>0. */
23723 if (stacki >= ARRAY_SIZE (stack) - 1)
23725 complaint (&symfile_complaints,
23726 _("location description stack overflow"));
23732 complaint (&symfile_complaints,
23733 _("location description stack underflow"));
23737 return (stack[stacki]);
23740 /* memory allocation interface */
23742 static struct dwarf_block *
23743 dwarf_alloc_block (struct dwarf2_cu *cu)
23745 return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23748 static struct die_info *
23749 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23751 struct die_info *die;
23752 size_t size = sizeof (struct die_info);
23755 size += (num_attrs - 1) * sizeof (struct attribute);
23757 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23758 memset (die, 0, sizeof (struct die_info));
23763 /* Macro support. */
23765 /* Return file name relative to the compilation directory of file number I in
23766 *LH's file name table. The result is allocated using xmalloc; the caller is
23767 responsible for freeing it. */
23770 file_file_name (int file, struct line_header *lh)
23772 /* Is the file number a valid index into the line header's file name
23773 table? Remember that file numbers start with one, not zero. */
23774 if (1 <= file && file <= lh->file_names.size ())
23776 const file_entry &fe = lh->file_names[file - 1];
23778 if (!IS_ABSOLUTE_PATH (fe.name))
23780 const char *dir = fe.include_dir (lh);
23782 return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23784 return xstrdup (fe.name);
23788 /* The compiler produced a bogus file number. We can at least
23789 record the macro definitions made in the file, even if we
23790 won't be able to find the file by name. */
23791 char fake_name[80];
23793 xsnprintf (fake_name, sizeof (fake_name),
23794 "<bad macro file number %d>", file);
23796 complaint (&symfile_complaints,
23797 _("bad file number in macro information (%d)"),
23800 return xstrdup (fake_name);
23804 /* Return the full name of file number I in *LH's file name table.
23805 Use COMP_DIR as the name of the current directory of the
23806 compilation. The result is allocated using xmalloc; the caller is
23807 responsible for freeing it. */
23809 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23811 /* Is the file number a valid index into the line header's file name
23812 table? Remember that file numbers start with one, not zero. */
23813 if (1 <= file && file <= lh->file_names.size ())
23815 char *relative = file_file_name (file, lh);
23817 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23819 return reconcat (relative, comp_dir, SLASH_STRING,
23820 relative, (char *) NULL);
23823 return file_file_name (file, lh);
23827 static struct macro_source_file *
23828 macro_start_file (int file, int line,
23829 struct macro_source_file *current_file,
23830 struct line_header *lh)
23832 /* File name relative to the compilation directory of this source file. */
23833 char *file_name = file_file_name (file, lh);
23835 if (! current_file)
23837 /* Note: We don't create a macro table for this compilation unit
23838 at all until we actually get a filename. */
23839 struct macro_table *macro_table = get_macro_table ();
23841 /* If we have no current file, then this must be the start_file
23842 directive for the compilation unit's main source file. */
23843 current_file = macro_set_main (macro_table, file_name);
23844 macro_define_special (macro_table);
23847 current_file = macro_include (current_file, line, file_name);
23851 return current_file;
23854 static const char *
23855 consume_improper_spaces (const char *p, const char *body)
23859 complaint (&symfile_complaints,
23860 _("macro definition contains spaces "
23861 "in formal argument list:\n`%s'"),
23873 parse_macro_definition (struct macro_source_file *file, int line,
23878 /* The body string takes one of two forms. For object-like macro
23879 definitions, it should be:
23881 <macro name> " " <definition>
23883 For function-like macro definitions, it should be:
23885 <macro name> "() " <definition>
23887 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
23889 Spaces may appear only where explicitly indicated, and in the
23892 The Dwarf 2 spec says that an object-like macro's name is always
23893 followed by a space, but versions of GCC around March 2002 omit
23894 the space when the macro's definition is the empty string.
23896 The Dwarf 2 spec says that there should be no spaces between the
23897 formal arguments in a function-like macro's formal argument list,
23898 but versions of GCC around March 2002 include spaces after the
23902 /* Find the extent of the macro name. The macro name is terminated
23903 by either a space or null character (for an object-like macro) or
23904 an opening paren (for a function-like macro). */
23905 for (p = body; *p; p++)
23906 if (*p == ' ' || *p == '(')
23909 if (*p == ' ' || *p == '\0')
23911 /* It's an object-like macro. */
23912 int name_len = p - body;
23913 char *name = savestring (body, name_len);
23914 const char *replacement;
23917 replacement = body + name_len + 1;
23920 dwarf2_macro_malformed_definition_complaint (body);
23921 replacement = body + name_len;
23924 macro_define_object (file, line, name, replacement);
23928 else if (*p == '(')
23930 /* It's a function-like macro. */
23931 char *name = savestring (body, p - body);
23934 char **argv = XNEWVEC (char *, argv_size);
23938 p = consume_improper_spaces (p, body);
23940 /* Parse the formal argument list. */
23941 while (*p && *p != ')')
23943 /* Find the extent of the current argument name. */
23944 const char *arg_start = p;
23946 while (*p && *p != ',' && *p != ')' && *p != ' ')
23949 if (! *p || p == arg_start)
23950 dwarf2_macro_malformed_definition_complaint (body);
23953 /* Make sure argv has room for the new argument. */
23954 if (argc >= argv_size)
23957 argv = XRESIZEVEC (char *, argv, argv_size);
23960 argv[argc++] = savestring (arg_start, p - arg_start);
23963 p = consume_improper_spaces (p, body);
23965 /* Consume the comma, if present. */
23970 p = consume_improper_spaces (p, body);
23979 /* Perfectly formed definition, no complaints. */
23980 macro_define_function (file, line, name,
23981 argc, (const char **) argv,
23983 else if (*p == '\0')
23985 /* Complain, but do define it. */
23986 dwarf2_macro_malformed_definition_complaint (body);
23987 macro_define_function (file, line, name,
23988 argc, (const char **) argv,
23992 /* Just complain. */
23993 dwarf2_macro_malformed_definition_complaint (body);
23996 /* Just complain. */
23997 dwarf2_macro_malformed_definition_complaint (body);
24003 for (i = 0; i < argc; i++)
24009 dwarf2_macro_malformed_definition_complaint (body);
24012 /* Skip some bytes from BYTES according to the form given in FORM.
24013 Returns the new pointer. */
24015 static const gdb_byte *
24016 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24017 enum dwarf_form form,
24018 unsigned int offset_size,
24019 struct dwarf2_section_info *section)
24021 unsigned int bytes_read;
24025 case DW_FORM_data1:
24030 case DW_FORM_data2:
24034 case DW_FORM_data4:
24038 case DW_FORM_data8:
24042 case DW_FORM_data16:
24046 case DW_FORM_string:
24047 read_direct_string (abfd, bytes, &bytes_read);
24048 bytes += bytes_read;
24051 case DW_FORM_sec_offset:
24053 case DW_FORM_GNU_strp_alt:
24054 bytes += offset_size;
24057 case DW_FORM_block:
24058 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24059 bytes += bytes_read;
24062 case DW_FORM_block1:
24063 bytes += 1 + read_1_byte (abfd, bytes);
24065 case DW_FORM_block2:
24066 bytes += 2 + read_2_bytes (abfd, bytes);
24068 case DW_FORM_block4:
24069 bytes += 4 + read_4_bytes (abfd, bytes);
24072 case DW_FORM_sdata:
24073 case DW_FORM_udata:
24074 case DW_FORM_GNU_addr_index:
24075 case DW_FORM_GNU_str_index:
24076 bytes = gdb_skip_leb128 (bytes, buffer_end);
24079 dwarf2_section_buffer_overflow_complaint (section);
24084 case DW_FORM_implicit_const:
24089 complaint (&symfile_complaints,
24090 _("invalid form 0x%x in `%s'"),
24091 form, get_section_name (section));
24099 /* A helper for dwarf_decode_macros that handles skipping an unknown
24100 opcode. Returns an updated pointer to the macro data buffer; or,
24101 on error, issues a complaint and returns NULL. */
24103 static const gdb_byte *
24104 skip_unknown_opcode (unsigned int opcode,
24105 const gdb_byte **opcode_definitions,
24106 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24108 unsigned int offset_size,
24109 struct dwarf2_section_info *section)
24111 unsigned int bytes_read, i;
24113 const gdb_byte *defn;
24115 if (opcode_definitions[opcode] == NULL)
24117 complaint (&symfile_complaints,
24118 _("unrecognized DW_MACFINO opcode 0x%x"),
24123 defn = opcode_definitions[opcode];
24124 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24125 defn += bytes_read;
24127 for (i = 0; i < arg; ++i)
24129 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24130 (enum dwarf_form) defn[i], offset_size,
24132 if (mac_ptr == NULL)
24134 /* skip_form_bytes already issued the complaint. */
24142 /* A helper function which parses the header of a macro section.
24143 If the macro section is the extended (for now called "GNU") type,
24144 then this updates *OFFSET_SIZE. Returns a pointer to just after
24145 the header, or issues a complaint and returns NULL on error. */
24147 static const gdb_byte *
24148 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24150 const gdb_byte *mac_ptr,
24151 unsigned int *offset_size,
24152 int section_is_gnu)
24154 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24156 if (section_is_gnu)
24158 unsigned int version, flags;
24160 version = read_2_bytes (abfd, mac_ptr);
24161 if (version != 4 && version != 5)
24163 complaint (&symfile_complaints,
24164 _("unrecognized version `%d' in .debug_macro section"),
24170 flags = read_1_byte (abfd, mac_ptr);
24172 *offset_size = (flags & 1) ? 8 : 4;
24174 if ((flags & 2) != 0)
24175 /* We don't need the line table offset. */
24176 mac_ptr += *offset_size;
24178 /* Vendor opcode descriptions. */
24179 if ((flags & 4) != 0)
24181 unsigned int i, count;
24183 count = read_1_byte (abfd, mac_ptr);
24185 for (i = 0; i < count; ++i)
24187 unsigned int opcode, bytes_read;
24190 opcode = read_1_byte (abfd, mac_ptr);
24192 opcode_definitions[opcode] = mac_ptr;
24193 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24194 mac_ptr += bytes_read;
24203 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24204 including DW_MACRO_import. */
24207 dwarf_decode_macro_bytes (struct dwarf2_per_objfile *dwarf2_per_objfile,
24209 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24210 struct macro_source_file *current_file,
24211 struct line_header *lh,
24212 struct dwarf2_section_info *section,
24213 int section_is_gnu, int section_is_dwz,
24214 unsigned int offset_size,
24215 htab_t include_hash)
24217 struct objfile *objfile = dwarf2_per_objfile->objfile;
24218 enum dwarf_macro_record_type macinfo_type;
24219 int at_commandline;
24220 const gdb_byte *opcode_definitions[256];
24222 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24223 &offset_size, section_is_gnu);
24224 if (mac_ptr == NULL)
24226 /* We already issued a complaint. */
24230 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24231 GDB is still reading the definitions from command line. First
24232 DW_MACINFO_start_file will need to be ignored as it was already executed
24233 to create CURRENT_FILE for the main source holding also the command line
24234 definitions. On first met DW_MACINFO_start_file this flag is reset to
24235 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24237 at_commandline = 1;
24241 /* Do we at least have room for a macinfo type byte? */
24242 if (mac_ptr >= mac_end)
24244 dwarf2_section_buffer_overflow_complaint (section);
24248 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24251 /* Note that we rely on the fact that the corresponding GNU and
24252 DWARF constants are the same. */
24254 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24255 switch (macinfo_type)
24257 /* A zero macinfo type indicates the end of the macro
24262 case DW_MACRO_define:
24263 case DW_MACRO_undef:
24264 case DW_MACRO_define_strp:
24265 case DW_MACRO_undef_strp:
24266 case DW_MACRO_define_sup:
24267 case DW_MACRO_undef_sup:
24269 unsigned int bytes_read;
24274 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24275 mac_ptr += bytes_read;
24277 if (macinfo_type == DW_MACRO_define
24278 || macinfo_type == DW_MACRO_undef)
24280 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24281 mac_ptr += bytes_read;
24285 LONGEST str_offset;
24287 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24288 mac_ptr += offset_size;
24290 if (macinfo_type == DW_MACRO_define_sup
24291 || macinfo_type == DW_MACRO_undef_sup
24294 struct dwz_file *dwz
24295 = dwarf2_get_dwz_file (dwarf2_per_objfile);
24297 body = read_indirect_string_from_dwz (objfile,
24301 body = read_indirect_string_at_offset (dwarf2_per_objfile,
24305 is_define = (macinfo_type == DW_MACRO_define
24306 || macinfo_type == DW_MACRO_define_strp
24307 || macinfo_type == DW_MACRO_define_sup);
24308 if (! current_file)
24310 /* DWARF violation as no main source is present. */
24311 complaint (&symfile_complaints,
24312 _("debug info with no main source gives macro %s "
24314 is_define ? _("definition") : _("undefinition"),
24318 if ((line == 0 && !at_commandline)
24319 || (line != 0 && at_commandline))
24320 complaint (&symfile_complaints,
24321 _("debug info gives %s macro %s with %s line %d: %s"),
24322 at_commandline ? _("command-line") : _("in-file"),
24323 is_define ? _("definition") : _("undefinition"),
24324 line == 0 ? _("zero") : _("non-zero"), line, body);
24327 parse_macro_definition (current_file, line, body);
24330 gdb_assert (macinfo_type == DW_MACRO_undef
24331 || macinfo_type == DW_MACRO_undef_strp
24332 || macinfo_type == DW_MACRO_undef_sup);
24333 macro_undef (current_file, line, body);
24338 case DW_MACRO_start_file:
24340 unsigned int bytes_read;
24343 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24344 mac_ptr += bytes_read;
24345 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24346 mac_ptr += bytes_read;
24348 if ((line == 0 && !at_commandline)
24349 || (line != 0 && at_commandline))
24350 complaint (&symfile_complaints,
24351 _("debug info gives source %d included "
24352 "from %s at %s line %d"),
24353 file, at_commandline ? _("command-line") : _("file"),
24354 line == 0 ? _("zero") : _("non-zero"), line);
24356 if (at_commandline)
24358 /* This DW_MACRO_start_file was executed in the
24360 at_commandline = 0;
24363 current_file = macro_start_file (file, line, current_file, lh);
24367 case DW_MACRO_end_file:
24368 if (! current_file)
24369 complaint (&symfile_complaints,
24370 _("macro debug info has an unmatched "
24371 "`close_file' directive"));
24374 current_file = current_file->included_by;
24375 if (! current_file)
24377 enum dwarf_macro_record_type next_type;
24379 /* GCC circa March 2002 doesn't produce the zero
24380 type byte marking the end of the compilation
24381 unit. Complain if it's not there, but exit no
24384 /* Do we at least have room for a macinfo type byte? */
24385 if (mac_ptr >= mac_end)
24387 dwarf2_section_buffer_overflow_complaint (section);
24391 /* We don't increment mac_ptr here, so this is just
24394 = (enum dwarf_macro_record_type) read_1_byte (abfd,
24396 if (next_type != 0)
24397 complaint (&symfile_complaints,
24398 _("no terminating 0-type entry for "
24399 "macros in `.debug_macinfo' section"));
24406 case DW_MACRO_import:
24407 case DW_MACRO_import_sup:
24411 bfd *include_bfd = abfd;
24412 struct dwarf2_section_info *include_section = section;
24413 const gdb_byte *include_mac_end = mac_end;
24414 int is_dwz = section_is_dwz;
24415 const gdb_byte *new_mac_ptr;
24417 offset = read_offset_1 (abfd, mac_ptr, offset_size);
24418 mac_ptr += offset_size;
24420 if (macinfo_type == DW_MACRO_import_sup)
24422 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24424 dwarf2_read_section (objfile, &dwz->macro);
24426 include_section = &dwz->macro;
24427 include_bfd = get_section_bfd_owner (include_section);
24428 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24432 new_mac_ptr = include_section->buffer + offset;
24433 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24437 /* This has actually happened; see
24438 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24439 complaint (&symfile_complaints,
24440 _("recursive DW_MACRO_import in "
24441 ".debug_macro section"));
24445 *slot = (void *) new_mac_ptr;
24447 dwarf_decode_macro_bytes (dwarf2_per_objfile,
24448 include_bfd, new_mac_ptr,
24449 include_mac_end, current_file, lh,
24450 section, section_is_gnu, is_dwz,
24451 offset_size, include_hash);
24453 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24458 case DW_MACINFO_vendor_ext:
24459 if (!section_is_gnu)
24461 unsigned int bytes_read;
24463 /* This reads the constant, but since we don't recognize
24464 any vendor extensions, we ignore it. */
24465 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24466 mac_ptr += bytes_read;
24467 read_direct_string (abfd, mac_ptr, &bytes_read);
24468 mac_ptr += bytes_read;
24470 /* We don't recognize any vendor extensions. */
24476 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24477 mac_ptr, mac_end, abfd, offset_size,
24479 if (mac_ptr == NULL)
24484 } while (macinfo_type != 0);
24488 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24489 int section_is_gnu)
24491 struct dwarf2_per_objfile *dwarf2_per_objfile
24492 = cu->per_cu->dwarf2_per_objfile;
24493 struct objfile *objfile = dwarf2_per_objfile->objfile;
24494 struct line_header *lh = cu->line_header;
24496 const gdb_byte *mac_ptr, *mac_end;
24497 struct macro_source_file *current_file = 0;
24498 enum dwarf_macro_record_type macinfo_type;
24499 unsigned int offset_size = cu->header.offset_size;
24500 const gdb_byte *opcode_definitions[256];
24502 struct dwarf2_section_info *section;
24503 const char *section_name;
24505 if (cu->dwo_unit != NULL)
24507 if (section_is_gnu)
24509 section = &cu->dwo_unit->dwo_file->sections.macro;
24510 section_name = ".debug_macro.dwo";
24514 section = &cu->dwo_unit->dwo_file->sections.macinfo;
24515 section_name = ".debug_macinfo.dwo";
24520 if (section_is_gnu)
24522 section = &dwarf2_per_objfile->macro;
24523 section_name = ".debug_macro";
24527 section = &dwarf2_per_objfile->macinfo;
24528 section_name = ".debug_macinfo";
24532 dwarf2_read_section (objfile, section);
24533 if (section->buffer == NULL)
24535 complaint (&symfile_complaints, _("missing %s section"), section_name);
24538 abfd = get_section_bfd_owner (section);
24540 /* First pass: Find the name of the base filename.
24541 This filename is needed in order to process all macros whose definition
24542 (or undefinition) comes from the command line. These macros are defined
24543 before the first DW_MACINFO_start_file entry, and yet still need to be
24544 associated to the base file.
24546 To determine the base file name, we scan the macro definitions until we
24547 reach the first DW_MACINFO_start_file entry. We then initialize
24548 CURRENT_FILE accordingly so that any macro definition found before the
24549 first DW_MACINFO_start_file can still be associated to the base file. */
24551 mac_ptr = section->buffer + offset;
24552 mac_end = section->buffer + section->size;
24554 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24555 &offset_size, section_is_gnu);
24556 if (mac_ptr == NULL)
24558 /* We already issued a complaint. */
24564 /* Do we at least have room for a macinfo type byte? */
24565 if (mac_ptr >= mac_end)
24567 /* Complaint is printed during the second pass as GDB will probably
24568 stop the first pass earlier upon finding
24569 DW_MACINFO_start_file. */
24573 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24576 /* Note that we rely on the fact that the corresponding GNU and
24577 DWARF constants are the same. */
24579 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24580 switch (macinfo_type)
24582 /* A zero macinfo type indicates the end of the macro
24587 case DW_MACRO_define:
24588 case DW_MACRO_undef:
24589 /* Only skip the data by MAC_PTR. */
24591 unsigned int bytes_read;
24593 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24594 mac_ptr += bytes_read;
24595 read_direct_string (abfd, mac_ptr, &bytes_read);
24596 mac_ptr += bytes_read;
24600 case DW_MACRO_start_file:
24602 unsigned int bytes_read;
24605 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24606 mac_ptr += bytes_read;
24607 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24608 mac_ptr += bytes_read;
24610 current_file = macro_start_file (file, line, current_file, lh);
24614 case DW_MACRO_end_file:
24615 /* No data to skip by MAC_PTR. */
24618 case DW_MACRO_define_strp:
24619 case DW_MACRO_undef_strp:
24620 case DW_MACRO_define_sup:
24621 case DW_MACRO_undef_sup:
24623 unsigned int bytes_read;
24625 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24626 mac_ptr += bytes_read;
24627 mac_ptr += offset_size;
24631 case DW_MACRO_import:
24632 case DW_MACRO_import_sup:
24633 /* Note that, according to the spec, a transparent include
24634 chain cannot call DW_MACRO_start_file. So, we can just
24635 skip this opcode. */
24636 mac_ptr += offset_size;
24639 case DW_MACINFO_vendor_ext:
24640 /* Only skip the data by MAC_PTR. */
24641 if (!section_is_gnu)
24643 unsigned int bytes_read;
24645 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24646 mac_ptr += bytes_read;
24647 read_direct_string (abfd, mac_ptr, &bytes_read);
24648 mac_ptr += bytes_read;
24653 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24654 mac_ptr, mac_end, abfd, offset_size,
24656 if (mac_ptr == NULL)
24661 } while (macinfo_type != 0 && current_file == NULL);
24663 /* Second pass: Process all entries.
24665 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24666 command-line macro definitions/undefinitions. This flag is unset when we
24667 reach the first DW_MACINFO_start_file entry. */
24669 htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24671 NULL, xcalloc, xfree));
24672 mac_ptr = section->buffer + offset;
24673 slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24674 *slot = (void *) mac_ptr;
24675 dwarf_decode_macro_bytes (dwarf2_per_objfile,
24676 abfd, mac_ptr, mac_end,
24677 current_file, lh, section,
24678 section_is_gnu, 0, offset_size,
24679 include_hash.get ());
24682 /* Check if the attribute's form is a DW_FORM_block*
24683 if so return true else false. */
24686 attr_form_is_block (const struct attribute *attr)
24688 return (attr == NULL ? 0 :
24689 attr->form == DW_FORM_block1
24690 || attr->form == DW_FORM_block2
24691 || attr->form == DW_FORM_block4
24692 || attr->form == DW_FORM_block
24693 || attr->form == DW_FORM_exprloc);
24696 /* Return non-zero if ATTR's value is a section offset --- classes
24697 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24698 You may use DW_UNSND (attr) to retrieve such offsets.
24700 Section 7.5.4, "Attribute Encodings", explains that no attribute
24701 may have a value that belongs to more than one of these classes; it
24702 would be ambiguous if we did, because we use the same forms for all
24706 attr_form_is_section_offset (const struct attribute *attr)
24708 return (attr->form == DW_FORM_data4
24709 || attr->form == DW_FORM_data8
24710 || attr->form == DW_FORM_sec_offset);
24713 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24714 zero otherwise. When this function returns true, you can apply
24715 dwarf2_get_attr_constant_value to it.
24717 However, note that for some attributes you must check
24718 attr_form_is_section_offset before using this test. DW_FORM_data4
24719 and DW_FORM_data8 are members of both the constant class, and of
24720 the classes that contain offsets into other debug sections
24721 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
24722 that, if an attribute's can be either a constant or one of the
24723 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24724 taken as section offsets, not constants.
24726 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24727 cannot handle that. */
24730 attr_form_is_constant (const struct attribute *attr)
24732 switch (attr->form)
24734 case DW_FORM_sdata:
24735 case DW_FORM_udata:
24736 case DW_FORM_data1:
24737 case DW_FORM_data2:
24738 case DW_FORM_data4:
24739 case DW_FORM_data8:
24740 case DW_FORM_implicit_const:
24748 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24749 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
24752 attr_form_is_ref (const struct attribute *attr)
24754 switch (attr->form)
24756 case DW_FORM_ref_addr:
24761 case DW_FORM_ref_udata:
24762 case DW_FORM_GNU_ref_alt:
24769 /* Return the .debug_loc section to use for CU.
24770 For DWO files use .debug_loc.dwo. */
24772 static struct dwarf2_section_info *
24773 cu_debug_loc_section (struct dwarf2_cu *cu)
24775 struct dwarf2_per_objfile *dwarf2_per_objfile
24776 = cu->per_cu->dwarf2_per_objfile;
24780 struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24782 return cu->header.version >= 5 ? §ions->loclists : §ions->loc;
24784 return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24785 : &dwarf2_per_objfile->loc);
24788 /* A helper function that fills in a dwarf2_loclist_baton. */
24791 fill_in_loclist_baton (struct dwarf2_cu *cu,
24792 struct dwarf2_loclist_baton *baton,
24793 const struct attribute *attr)
24795 struct dwarf2_per_objfile *dwarf2_per_objfile
24796 = cu->per_cu->dwarf2_per_objfile;
24797 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24799 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24801 baton->per_cu = cu->per_cu;
24802 gdb_assert (baton->per_cu);
24803 /* We don't know how long the location list is, but make sure we
24804 don't run off the edge of the section. */
24805 baton->size = section->size - DW_UNSND (attr);
24806 baton->data = section->buffer + DW_UNSND (attr);
24807 baton->base_address = cu->base_address;
24808 baton->from_dwo = cu->dwo_unit != NULL;
24812 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24813 struct dwarf2_cu *cu, int is_block)
24815 struct dwarf2_per_objfile *dwarf2_per_objfile
24816 = cu->per_cu->dwarf2_per_objfile;
24817 struct objfile *objfile = dwarf2_per_objfile->objfile;
24818 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24820 if (attr_form_is_section_offset (attr)
24821 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24822 the section. If so, fall through to the complaint in the
24824 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24826 struct dwarf2_loclist_baton *baton;
24828 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24830 fill_in_loclist_baton (cu, baton, attr);
24832 if (cu->base_known == 0)
24833 complaint (&symfile_complaints,
24834 _("Location list used without "
24835 "specifying the CU base address."));
24837 SYMBOL_ACLASS_INDEX (sym) = (is_block
24838 ? dwarf2_loclist_block_index
24839 : dwarf2_loclist_index);
24840 SYMBOL_LOCATION_BATON (sym) = baton;
24844 struct dwarf2_locexpr_baton *baton;
24846 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
24847 baton->per_cu = cu->per_cu;
24848 gdb_assert (baton->per_cu);
24850 if (attr_form_is_block (attr))
24852 /* Note that we're just copying the block's data pointer
24853 here, not the actual data. We're still pointing into the
24854 info_buffer for SYM's objfile; right now we never release
24855 that buffer, but when we do clean up properly this may
24857 baton->size = DW_BLOCK (attr)->size;
24858 baton->data = DW_BLOCK (attr)->data;
24862 dwarf2_invalid_attrib_class_complaint ("location description",
24863 SYMBOL_NATURAL_NAME (sym));
24867 SYMBOL_ACLASS_INDEX (sym) = (is_block
24868 ? dwarf2_locexpr_block_index
24869 : dwarf2_locexpr_index);
24870 SYMBOL_LOCATION_BATON (sym) = baton;
24874 /* Return the OBJFILE associated with the compilation unit CU. If CU
24875 came from a separate debuginfo file, then the master objfile is
24879 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
24881 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
24883 /* Return the master objfile, so that we can report and look up the
24884 correct file containing this variable. */
24885 if (objfile->separate_debug_objfile_backlink)
24886 objfile = objfile->separate_debug_objfile_backlink;
24891 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
24892 (CU_HEADERP is unused in such case) or prepare a temporary copy at
24893 CU_HEADERP first. */
24895 static const struct comp_unit_head *
24896 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
24897 struct dwarf2_per_cu_data *per_cu)
24899 const gdb_byte *info_ptr;
24902 return &per_cu->cu->header;
24904 info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
24906 memset (cu_headerp, 0, sizeof (*cu_headerp));
24907 read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
24908 rcuh_kind::COMPILE);
24913 /* Return the address size given in the compilation unit header for CU. */
24916 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
24918 struct comp_unit_head cu_header_local;
24919 const struct comp_unit_head *cu_headerp;
24921 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
24923 return cu_headerp->addr_size;
24926 /* Return the offset size given in the compilation unit header for CU. */
24929 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
24931 struct comp_unit_head cu_header_local;
24932 const struct comp_unit_head *cu_headerp;
24934 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
24936 return cu_headerp->offset_size;
24939 /* See its dwarf2loc.h declaration. */
24942 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
24944 struct comp_unit_head cu_header_local;
24945 const struct comp_unit_head *cu_headerp;
24947 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
24949 if (cu_headerp->version == 2)
24950 return cu_headerp->addr_size;
24952 return cu_headerp->offset_size;
24955 /* Return the text offset of the CU. The returned offset comes from
24956 this CU's objfile. If this objfile came from a separate debuginfo
24957 file, then the offset may be different from the corresponding
24958 offset in the parent objfile. */
24961 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
24963 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
24965 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
24968 /* Return DWARF version number of PER_CU. */
24971 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
24973 return per_cu->dwarf_version;
24976 /* Locate the .debug_info compilation unit from CU's objfile which contains
24977 the DIE at OFFSET. Raises an error on failure. */
24979 static struct dwarf2_per_cu_data *
24980 dwarf2_find_containing_comp_unit (sect_offset sect_off,
24981 unsigned int offset_in_dwz,
24982 struct dwarf2_per_objfile *dwarf2_per_objfile)
24984 struct dwarf2_per_cu_data *this_cu;
24986 const sect_offset *cu_off;
24989 high = dwarf2_per_objfile->all_comp_units.size () - 1;
24992 struct dwarf2_per_cu_data *mid_cu;
24993 int mid = low + (high - low) / 2;
24995 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
24996 cu_off = &mid_cu->sect_off;
24997 if (mid_cu->is_dwz > offset_in_dwz
24998 || (mid_cu->is_dwz == offset_in_dwz && *cu_off >= sect_off))
25003 gdb_assert (low == high);
25004 this_cu = dwarf2_per_objfile->all_comp_units[low];
25005 cu_off = &this_cu->sect_off;
25006 if (this_cu->is_dwz != offset_in_dwz || *cu_off > sect_off)
25008 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25009 error (_("Dwarf Error: could not find partial DIE containing "
25010 "offset %s [in module %s]"),
25011 sect_offset_str (sect_off),
25012 bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25014 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25016 return dwarf2_per_objfile->all_comp_units[low-1];
25020 this_cu = dwarf2_per_objfile->all_comp_units[low];
25021 if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25022 && sect_off >= this_cu->sect_off + this_cu->length)
25023 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25024 gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25029 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25031 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25032 : per_cu (per_cu_),
25035 checked_producer (0),
25036 producer_is_gxx_lt_4_6 (0),
25037 producer_is_gcc_lt_4_3 (0),
25038 producer_is_icc_lt_14 (0),
25039 processing_has_namespace_info (0)
25044 /* Destroy a dwarf2_cu. */
25046 dwarf2_cu::~dwarf2_cu ()
25051 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25054 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25055 enum language pretend_language)
25057 struct attribute *attr;
25059 /* Set the language we're debugging. */
25060 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25062 set_cu_language (DW_UNSND (attr), cu);
25065 cu->language = pretend_language;
25066 cu->language_defn = language_def (cu->language);
25069 cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25072 /* Increase the age counter on each cached compilation unit, and free
25073 any that are too old. */
25076 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25078 struct dwarf2_per_cu_data *per_cu, **last_chain;
25080 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25081 per_cu = dwarf2_per_objfile->read_in_chain;
25082 while (per_cu != NULL)
25084 per_cu->cu->last_used ++;
25085 if (per_cu->cu->last_used <= dwarf_max_cache_age)
25086 dwarf2_mark (per_cu->cu);
25087 per_cu = per_cu->cu->read_in_chain;
25090 per_cu = dwarf2_per_objfile->read_in_chain;
25091 last_chain = &dwarf2_per_objfile->read_in_chain;
25092 while (per_cu != NULL)
25094 struct dwarf2_per_cu_data *next_cu;
25096 next_cu = per_cu->cu->read_in_chain;
25098 if (!per_cu->cu->mark)
25101 *last_chain = next_cu;
25104 last_chain = &per_cu->cu->read_in_chain;
25110 /* Remove a single compilation unit from the cache. */
25113 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25115 struct dwarf2_per_cu_data *per_cu, **last_chain;
25116 struct dwarf2_per_objfile *dwarf2_per_objfile
25117 = target_per_cu->dwarf2_per_objfile;
25119 per_cu = dwarf2_per_objfile->read_in_chain;
25120 last_chain = &dwarf2_per_objfile->read_in_chain;
25121 while (per_cu != NULL)
25123 struct dwarf2_per_cu_data *next_cu;
25125 next_cu = per_cu->cu->read_in_chain;
25127 if (per_cu == target_per_cu)
25131 *last_chain = next_cu;
25135 last_chain = &per_cu->cu->read_in_chain;
25141 /* Release all extra memory associated with OBJFILE. */
25144 dwarf2_free_objfile (struct objfile *objfile)
25146 struct dwarf2_per_objfile *dwarf2_per_objfile
25147 = get_dwarf2_per_objfile (objfile);
25149 delete dwarf2_per_objfile;
25152 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25153 We store these in a hash table separate from the DIEs, and preserve them
25154 when the DIEs are flushed out of cache.
25156 The CU "per_cu" pointer is needed because offset alone is not enough to
25157 uniquely identify the type. A file may have multiple .debug_types sections,
25158 or the type may come from a DWO file. Furthermore, while it's more logical
25159 to use per_cu->section+offset, with Fission the section with the data is in
25160 the DWO file but we don't know that section at the point we need it.
25161 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25162 because we can enter the lookup routine, get_die_type_at_offset, from
25163 outside this file, and thus won't necessarily have PER_CU->cu.
25164 Fortunately, PER_CU is stable for the life of the objfile. */
25166 struct dwarf2_per_cu_offset_and_type
25168 const struct dwarf2_per_cu_data *per_cu;
25169 sect_offset sect_off;
25173 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25176 per_cu_offset_and_type_hash (const void *item)
25178 const struct dwarf2_per_cu_offset_and_type *ofs
25179 = (const struct dwarf2_per_cu_offset_and_type *) item;
25181 return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25184 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25187 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25189 const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25190 = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25191 const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25192 = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25194 return (ofs_lhs->per_cu == ofs_rhs->per_cu
25195 && ofs_lhs->sect_off == ofs_rhs->sect_off);
25198 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25199 table if necessary. For convenience, return TYPE.
25201 The DIEs reading must have careful ordering to:
25202 * Not cause infite loops trying to read in DIEs as a prerequisite for
25203 reading current DIE.
25204 * Not trying to dereference contents of still incompletely read in types
25205 while reading in other DIEs.
25206 * Enable referencing still incompletely read in types just by a pointer to
25207 the type without accessing its fields.
25209 Therefore caller should follow these rules:
25210 * Try to fetch any prerequisite types we may need to build this DIE type
25211 before building the type and calling set_die_type.
25212 * After building type call set_die_type for current DIE as soon as
25213 possible before fetching more types to complete the current type.
25214 * Make the type as complete as possible before fetching more types. */
25216 static struct type *
25217 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25219 struct dwarf2_per_objfile *dwarf2_per_objfile
25220 = cu->per_cu->dwarf2_per_objfile;
25221 struct dwarf2_per_cu_offset_and_type **slot, ofs;
25222 struct objfile *objfile = dwarf2_per_objfile->objfile;
25223 struct attribute *attr;
25224 struct dynamic_prop prop;
25226 /* For Ada types, make sure that the gnat-specific data is always
25227 initialized (if not already set). There are a few types where
25228 we should not be doing so, because the type-specific area is
25229 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25230 where the type-specific area is used to store the floatformat).
25231 But this is not a problem, because the gnat-specific information
25232 is actually not needed for these types. */
25233 if (need_gnat_info (cu)
25234 && TYPE_CODE (type) != TYPE_CODE_FUNC
25235 && TYPE_CODE (type) != TYPE_CODE_FLT
25236 && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25237 && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25238 && TYPE_CODE (type) != TYPE_CODE_METHOD
25239 && !HAVE_GNAT_AUX_INFO (type))
25240 INIT_GNAT_SPECIFIC (type);
25242 /* Read DW_AT_allocated and set in type. */
25243 attr = dwarf2_attr (die, DW_AT_allocated, cu);
25244 if (attr_form_is_block (attr))
25246 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25247 add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25249 else if (attr != NULL)
25251 complaint (&symfile_complaints,
25252 _("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25253 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25254 sect_offset_str (die->sect_off));
25257 /* Read DW_AT_associated and set in type. */
25258 attr = dwarf2_attr (die, DW_AT_associated, cu);
25259 if (attr_form_is_block (attr))
25261 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25262 add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25264 else if (attr != NULL)
25266 complaint (&symfile_complaints,
25267 _("DW_AT_associated has the wrong form (%s) at DIE %s"),
25268 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25269 sect_offset_str (die->sect_off));
25272 /* Read DW_AT_data_location and set in type. */
25273 attr = dwarf2_attr (die, DW_AT_data_location, cu);
25274 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25275 add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25277 if (dwarf2_per_objfile->die_type_hash == NULL)
25279 dwarf2_per_objfile->die_type_hash =
25280 htab_create_alloc_ex (127,
25281 per_cu_offset_and_type_hash,
25282 per_cu_offset_and_type_eq,
25284 &objfile->objfile_obstack,
25285 hashtab_obstack_allocate,
25286 dummy_obstack_deallocate);
25289 ofs.per_cu = cu->per_cu;
25290 ofs.sect_off = die->sect_off;
25292 slot = (struct dwarf2_per_cu_offset_and_type **)
25293 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25295 complaint (&symfile_complaints,
25296 _("A problem internal to GDB: DIE %s has type already set"),
25297 sect_offset_str (die->sect_off));
25298 *slot = XOBNEW (&objfile->objfile_obstack,
25299 struct dwarf2_per_cu_offset_and_type);
25304 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25305 or return NULL if the die does not have a saved type. */
25307 static struct type *
25308 get_die_type_at_offset (sect_offset sect_off,
25309 struct dwarf2_per_cu_data *per_cu)
25311 struct dwarf2_per_cu_offset_and_type *slot, ofs;
25312 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25314 if (dwarf2_per_objfile->die_type_hash == NULL)
25317 ofs.per_cu = per_cu;
25318 ofs.sect_off = sect_off;
25319 slot = ((struct dwarf2_per_cu_offset_and_type *)
25320 htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25327 /* Look up the type for DIE in CU in die_type_hash,
25328 or return NULL if DIE does not have a saved type. */
25330 static struct type *
25331 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25333 return get_die_type_at_offset (die->sect_off, cu->per_cu);
25336 /* Add a dependence relationship from CU to REF_PER_CU. */
25339 dwarf2_add_dependence (struct dwarf2_cu *cu,
25340 struct dwarf2_per_cu_data *ref_per_cu)
25344 if (cu->dependencies == NULL)
25346 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25347 NULL, &cu->comp_unit_obstack,
25348 hashtab_obstack_allocate,
25349 dummy_obstack_deallocate);
25351 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25353 *slot = ref_per_cu;
25356 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25357 Set the mark field in every compilation unit in the
25358 cache that we must keep because we are keeping CU. */
25361 dwarf2_mark_helper (void **slot, void *data)
25363 struct dwarf2_per_cu_data *per_cu;
25365 per_cu = (struct dwarf2_per_cu_data *) *slot;
25367 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25368 reading of the chain. As such dependencies remain valid it is not much
25369 useful to track and undo them during QUIT cleanups. */
25370 if (per_cu->cu == NULL)
25373 if (per_cu->cu->mark)
25375 per_cu->cu->mark = 1;
25377 if (per_cu->cu->dependencies != NULL)
25378 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25383 /* Set the mark field in CU and in every other compilation unit in the
25384 cache that we must keep because we are keeping CU. */
25387 dwarf2_mark (struct dwarf2_cu *cu)
25392 if (cu->dependencies != NULL)
25393 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25397 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25401 per_cu->cu->mark = 0;
25402 per_cu = per_cu->cu->read_in_chain;
25406 /* Trivial hash function for partial_die_info: the hash value of a DIE
25407 is its offset in .debug_info for this objfile. */
25410 partial_die_hash (const void *item)
25412 const struct partial_die_info *part_die
25413 = (const struct partial_die_info *) item;
25415 return to_underlying (part_die->sect_off);
25418 /* Trivial comparison function for partial_die_info structures: two DIEs
25419 are equal if they have the same offset. */
25422 partial_die_eq (const void *item_lhs, const void *item_rhs)
25424 const struct partial_die_info *part_die_lhs
25425 = (const struct partial_die_info *) item_lhs;
25426 const struct partial_die_info *part_die_rhs
25427 = (const struct partial_die_info *) item_rhs;
25429 return part_die_lhs->sect_off == part_die_rhs->sect_off;
25432 static struct cmd_list_element *set_dwarf_cmdlist;
25433 static struct cmd_list_element *show_dwarf_cmdlist;
25436 set_dwarf_cmd (const char *args, int from_tty)
25438 help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25443 show_dwarf_cmd (const char *args, int from_tty)
25445 cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25448 int dwarf_always_disassemble;
25451 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25452 struct cmd_list_element *c, const char *value)
25454 fprintf_filtered (file,
25455 _("Whether to always disassemble "
25456 "DWARF expressions is %s.\n"),
25461 show_check_physname (struct ui_file *file, int from_tty,
25462 struct cmd_list_element *c, const char *value)
25464 fprintf_filtered (file,
25465 _("Whether to check \"physname\" is %s.\n"),
25470 _initialize_dwarf2_read (void)
25473 dwarf2_objfile_data_key = register_objfile_data ();
25475 add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25476 Set DWARF specific variables.\n\
25477 Configure DWARF variables such as the cache size"),
25478 &set_dwarf_cmdlist, "maintenance set dwarf ",
25479 0/*allow-unknown*/, &maintenance_set_cmdlist);
25481 add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25482 Show DWARF specific variables\n\
25483 Show DWARF variables such as the cache size"),
25484 &show_dwarf_cmdlist, "maintenance show dwarf ",
25485 0/*allow-unknown*/, &maintenance_show_cmdlist);
25487 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25488 &dwarf_max_cache_age, _("\
25489 Set the upper bound on the age of cached DWARF compilation units."), _("\
25490 Show the upper bound on the age of cached DWARF compilation units."), _("\
25491 A higher limit means that cached compilation units will be stored\n\
25492 in memory longer, and more total memory will be used. Zero disables\n\
25493 caching, which can slow down startup."),
25495 show_dwarf_max_cache_age,
25496 &set_dwarf_cmdlist,
25497 &show_dwarf_cmdlist);
25499 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25500 &dwarf_always_disassemble, _("\
25501 Set whether `info address' always disassembles DWARF expressions."), _("\
25502 Show whether `info address' always disassembles DWARF expressions."), _("\
25503 When enabled, DWARF expressions are always printed in an assembly-like\n\
25504 syntax. When disabled, expressions will be printed in a more\n\
25505 conversational style, when possible."),
25507 show_dwarf_always_disassemble,
25508 &set_dwarf_cmdlist,
25509 &show_dwarf_cmdlist);
25511 add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25512 Set debugging of the DWARF reader."), _("\
25513 Show debugging of the DWARF reader."), _("\
25514 When enabled (non-zero), debugging messages are printed during DWARF\n\
25515 reading and symtab expansion. A value of 1 (one) provides basic\n\
25516 information. A value greater than 1 provides more verbose information."),
25519 &setdebuglist, &showdebuglist);
25521 add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25522 Set debugging of the DWARF DIE reader."), _("\
25523 Show debugging of the DWARF DIE reader."), _("\
25524 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25525 The value is the maximum depth to print."),
25528 &setdebuglist, &showdebuglist);
25530 add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25531 Set debugging of the dwarf line reader."), _("\
25532 Show debugging of the dwarf line reader."), _("\
25533 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25534 A value of 1 (one) provides basic information.\n\
25535 A value greater than 1 provides more verbose information."),
25538 &setdebuglist, &showdebuglist);
25540 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25541 Set cross-checking of \"physname\" code against demangler."), _("\
25542 Show cross-checking of \"physname\" code against demangler."), _("\
25543 When enabled, GDB's internal \"physname\" code is checked against\n\
25545 NULL, show_check_physname,
25546 &setdebuglist, &showdebuglist);
25548 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25549 no_class, &use_deprecated_index_sections, _("\
25550 Set whether to use deprecated gdb_index sections."), _("\
25551 Show whether to use deprecated gdb_index sections."), _("\
25552 When enabled, deprecated .gdb_index sections are used anyway.\n\
25553 Normally they are ignored either because of a missing feature or\n\
25554 performance issue.\n\
25555 Warning: This option must be enabled before gdb reads the file."),
25558 &setlist, &showlist);
25560 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25561 &dwarf2_locexpr_funcs);
25562 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25563 &dwarf2_loclist_funcs);
25565 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25566 &dwarf2_block_frame_base_locexpr_funcs);
25567 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25568 &dwarf2_block_frame_base_loclist_funcs);
25571 selftests::register_test ("dw2_expand_symtabs_matching",
25572 selftests::dw2_expand_symtabs_matching::run_test);