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. */
40 #include "gdb-demangle.h"
41 #include "expression.h"
42 #include "filenames.h" /* for DOSish file names */
45 #include "complaints.h"
47 #include "dwarf2expr.h"
48 #include "dwarf2loc.h"
49 #include "cp-support.h"
55 #include "typeprint.h"
58 #include "completer.h"
63 #include "gdbcore.h" /* for gnutarget */
64 #include "gdb/gdb-index.h"
69 #include "filestuff.h"
71 #include "namespace.h"
72 #include "common/gdb_unlinker.h"
73 #include "common/function-view.h"
74 #include "common/gdb_optional.h"
75 #include "common/underlying.h"
76 #include "common/byte-vector.h"
77 #include "common/hash_enum.h"
78 #include "filename-seen-cache.h"
81 #include <sys/types.h>
83 #include <unordered_set>
84 #include <unordered_map>
88 #include <forward_list>
90 typedef struct symbol *symbolp;
93 /* When == 1, print basic high level tracing messages.
94 When > 1, be more verbose.
95 This is in contrast to the low level DIE reading of dwarf_die_debug. */
96 static unsigned int dwarf_read_debug = 0;
98 /* When non-zero, dump DIEs after they are read in. */
99 static unsigned int dwarf_die_debug = 0;
101 /* When non-zero, dump line number entries as they are read in. */
102 static unsigned int dwarf_line_debug = 0;
104 /* When non-zero, cross-check physname against demangler. */
105 static int check_physname = 0;
107 /* When non-zero, do not reject deprecated .gdb_index sections. */
108 static int use_deprecated_index_sections = 0;
110 static const struct objfile_data *dwarf2_objfile_data_key;
112 /* The "aclass" indices for various kinds of computed DWARF symbols. */
114 static int dwarf2_locexpr_index;
115 static int dwarf2_loclist_index;
116 static int dwarf2_locexpr_block_index;
117 static int dwarf2_loclist_block_index;
119 /* A descriptor for dwarf sections.
121 S.ASECTION, SIZE are typically initialized when the objfile is first
122 scanned. BUFFER, READIN are filled in later when the section is read.
123 If the section contained compressed data then SIZE is updated to record
124 the uncompressed size of the section.
126 DWP file format V2 introduces a wrinkle that is easiest to handle by
127 creating the concept of virtual sections contained within a real section.
128 In DWP V2 the sections of the input DWO files are concatenated together
129 into one section, but section offsets are kept relative to the original
131 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
132 the real section this "virtual" section is contained in, and BUFFER,SIZE
133 describe the virtual section. */
135 struct dwarf2_section_info
139 /* If this is a real section, the bfd section. */
141 /* If this is a virtual section, pointer to the containing ("real")
143 struct dwarf2_section_info *containing_section;
145 /* Pointer to section data, only valid if readin. */
146 const gdb_byte *buffer;
147 /* The size of the section, real or virtual. */
149 /* If this is a virtual section, the offset in the real section.
150 Only valid if is_virtual. */
151 bfd_size_type virtual_offset;
152 /* True if we have tried to read this section. */
154 /* True if this is a virtual section, False otherwise.
155 This specifies which of s.section and s.containing_section to use. */
159 typedef struct dwarf2_section_info dwarf2_section_info_def;
160 DEF_VEC_O (dwarf2_section_info_def);
162 /* All offsets in the index are of this type. It must be
163 architecture-independent. */
164 typedef uint32_t offset_type;
166 DEF_VEC_I (offset_type);
168 /* Ensure only legit values are used. */
169 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
171 gdb_assert ((unsigned int) (value) <= 1); \
172 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
175 /* Ensure only legit values are used. */
176 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
178 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
179 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
180 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
183 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
184 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
186 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
187 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
192 /* Convert VALUE between big- and little-endian. */
195 byte_swap (offset_type value)
199 result = (value & 0xff) << 24;
200 result |= (value & 0xff00) << 8;
201 result |= (value & 0xff0000) >> 8;
202 result |= (value & 0xff000000) >> 24;
206 #define MAYBE_SWAP(V) byte_swap (V)
209 #define MAYBE_SWAP(V) static_cast<offset_type> (V)
210 #endif /* WORDS_BIGENDIAN */
212 /* An index into a (C++) symbol name component in a symbol name as
213 recorded in the mapped_index's symbol table. For each C++ symbol
214 in the symbol table, we record one entry for the start of each
215 component in the symbol in a table of name components, and then
216 sort the table, in order to be able to binary search symbol names,
217 ignoring leading namespaces, both completion and regular look up.
218 For example, for symbol "A::B::C", we'll have an entry that points
219 to "A::B::C", another that points to "B::C", and another for "C".
220 Note that function symbols in GDB index have no parameter
221 information, just the function/method names. You can convert a
222 name_component to a "const char *" using the
223 'mapped_index::symbol_name_at(offset_type)' method. */
225 struct name_component
227 /* Offset in the symbol name where the component starts. Stored as
228 a (32-bit) offset instead of a pointer to save memory and improve
229 locality on 64-bit architectures. */
230 offset_type name_offset;
232 /* The symbol's index in the symbol and constant pool tables of a
237 /* Base class containing bits shared by both .gdb_index and
238 .debug_name indexes. */
240 struct mapped_index_base
242 /* The name_component table (a sorted vector). See name_component's
243 description above. */
244 std::vector<name_component> name_components;
246 /* How NAME_COMPONENTS is sorted. */
247 enum case_sensitivity name_components_casing;
249 /* Return the number of names in the symbol table. */
250 virtual size_t symbol_name_count () const = 0;
252 /* Get the name of the symbol at IDX in the symbol table. */
253 virtual const char *symbol_name_at (offset_type idx) const = 0;
255 /* Return whether the name at IDX in the symbol table should be
257 virtual bool symbol_name_slot_invalid (offset_type idx) const
262 /* Build the symbol name component sorted vector, if we haven't
264 void build_name_components ();
266 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
267 possible matches for LN_NO_PARAMS in the name component
269 std::pair<std::vector<name_component>::const_iterator,
270 std::vector<name_component>::const_iterator>
271 find_name_components_bounds (const lookup_name_info &ln_no_params) const;
273 /* Prevent deleting/destroying via a base class pointer. */
275 ~mapped_index_base() = default;
278 /* A description of the mapped index. The file format is described in
279 a comment by the code that writes the index. */
280 struct mapped_index final : public mapped_index_base
282 /* A slot/bucket in the symbol table hash. */
283 struct symbol_table_slot
285 const offset_type name;
286 const offset_type vec;
289 /* Index data format version. */
292 /* The total length of the buffer. */
295 /* The address table data. */
296 gdb::array_view<const gdb_byte> address_table;
298 /* The symbol table, implemented as a hash table. */
299 gdb::array_view<symbol_table_slot> symbol_table;
301 /* A pointer to the constant pool. */
302 const char *constant_pool;
304 bool symbol_name_slot_invalid (offset_type idx) const override
306 const auto &bucket = this->symbol_table[idx];
307 return bucket.name == 0 && bucket.vec;
310 /* Convenience method to get at the name of the symbol at IDX in the
312 const char *symbol_name_at (offset_type idx) const override
313 { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
315 size_t symbol_name_count () const override
316 { return this->symbol_table.size (); }
319 /* A description of the mapped .debug_names.
320 Uninitialized map has CU_COUNT 0. */
321 struct mapped_debug_names final : public mapped_index_base
323 mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
324 : dwarf2_per_objfile (dwarf2_per_objfile_)
327 struct dwarf2_per_objfile *dwarf2_per_objfile;
328 bfd_endian dwarf5_byte_order;
329 bool dwarf5_is_dwarf64;
330 bool augmentation_is_gdb;
332 uint32_t cu_count = 0;
333 uint32_t tu_count, bucket_count, name_count;
334 const gdb_byte *cu_table_reordered, *tu_table_reordered;
335 const uint32_t *bucket_table_reordered, *hash_table_reordered;
336 const gdb_byte *name_table_string_offs_reordered;
337 const gdb_byte *name_table_entry_offs_reordered;
338 const gdb_byte *entry_pool;
345 /* Attribute name DW_IDX_*. */
348 /* Attribute form DW_FORM_*. */
351 /* Value if FORM is DW_FORM_implicit_const. */
352 LONGEST implicit_const;
354 std::vector<attr> attr_vec;
357 std::unordered_map<ULONGEST, index_val> abbrev_map;
359 const char *namei_to_name (uint32_t namei) const;
361 /* Implementation of the mapped_index_base virtual interface, for
362 the name_components cache. */
364 const char *symbol_name_at (offset_type idx) const override
365 { return namei_to_name (idx); }
367 size_t symbol_name_count () const override
368 { return this->name_count; }
371 typedef struct dwarf2_per_cu_data *dwarf2_per_cu_ptr;
372 DEF_VEC_P (dwarf2_per_cu_ptr);
376 int nr_uniq_abbrev_tables;
378 int nr_symtab_sharers;
379 int nr_stmt_less_type_units;
380 int nr_all_type_units_reallocs;
383 /* Collection of data recorded per objfile.
384 This hangs off of dwarf2_objfile_data_key. */
386 struct dwarf2_per_objfile
388 /* Construct a dwarf2_per_objfile for OBJFILE. NAMES points to the
389 dwarf2 section names, or is NULL if the standard ELF names are
391 dwarf2_per_objfile (struct objfile *objfile,
392 const dwarf2_debug_sections *names);
394 ~dwarf2_per_objfile ();
396 DISABLE_COPY_AND_ASSIGN (dwarf2_per_objfile);
398 /* Free all cached compilation units. */
399 void free_cached_comp_units ();
401 /* This function is mapped across the sections and remembers the
402 offset and size of each of the debugging sections we are
404 void locate_sections (bfd *abfd, asection *sectp,
405 const dwarf2_debug_sections &names);
408 dwarf2_section_info info {};
409 dwarf2_section_info abbrev {};
410 dwarf2_section_info line {};
411 dwarf2_section_info loc {};
412 dwarf2_section_info loclists {};
413 dwarf2_section_info macinfo {};
414 dwarf2_section_info macro {};
415 dwarf2_section_info str {};
416 dwarf2_section_info line_str {};
417 dwarf2_section_info ranges {};
418 dwarf2_section_info rnglists {};
419 dwarf2_section_info addr {};
420 dwarf2_section_info frame {};
421 dwarf2_section_info eh_frame {};
422 dwarf2_section_info gdb_index {};
423 dwarf2_section_info debug_names {};
424 dwarf2_section_info debug_aranges {};
426 VEC (dwarf2_section_info_def) *types = NULL;
429 struct objfile *objfile = NULL;
431 /* Table of all the compilation units. This is used to locate
432 the target compilation unit of a particular reference. */
433 struct dwarf2_per_cu_data **all_comp_units = NULL;
435 /* The number of compilation units in ALL_COMP_UNITS. */
436 int n_comp_units = 0;
438 /* The number of .debug_types-related CUs. */
439 int n_type_units = 0;
441 /* The number of elements allocated in all_type_units.
442 If there are skeleton-less TUs, we add them to all_type_units lazily. */
443 int n_allocated_type_units = 0;
445 /* The .debug_types-related CUs (TUs).
446 This is stored in malloc space because we may realloc it. */
447 struct signatured_type **all_type_units = NULL;
449 /* Table of struct type_unit_group objects.
450 The hash key is the DW_AT_stmt_list value. */
451 htab_t type_unit_groups {};
453 /* A table mapping .debug_types signatures to its signatured_type entry.
454 This is NULL if the .debug_types section hasn't been read in yet. */
455 htab_t signatured_types {};
457 /* Type unit statistics, to see how well the scaling improvements
459 struct tu_stats tu_stats {};
461 /* A chain of compilation units that are currently read in, so that
462 they can be freed later. */
463 dwarf2_per_cu_data *read_in_chain = NULL;
465 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
466 This is NULL if the table hasn't been allocated yet. */
469 /* True if we've checked for whether there is a DWP file. */
470 bool dwp_checked = false;
472 /* The DWP file if there is one, or NULL. */
473 struct dwp_file *dwp_file = NULL;
475 /* The shared '.dwz' file, if one exists. This is used when the
476 original data was compressed using 'dwz -m'. */
477 struct dwz_file *dwz_file = NULL;
479 /* A flag indicating whether this objfile has a section loaded at a
481 bool has_section_at_zero = false;
483 /* True if we are using the mapped index,
484 or we are faking it for OBJF_READNOW's sake. */
485 bool using_index = false;
487 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
488 mapped_index *index_table = NULL;
490 /* The mapped index, or NULL if .debug_names is missing or not being used. */
491 std::unique_ptr<mapped_debug_names> debug_names_table;
493 /* When using index_table, this keeps track of all quick_file_names entries.
494 TUs typically share line table entries with a CU, so we maintain a
495 separate table of all line table entries to support the sharing.
496 Note that while there can be way more TUs than CUs, we've already
497 sorted all the TUs into "type unit groups", grouped by their
498 DW_AT_stmt_list value. Therefore the only sharing done here is with a
499 CU and its associated TU group if there is one. */
500 htab_t quick_file_names_table {};
502 /* Set during partial symbol reading, to prevent queueing of full
504 bool reading_partial_symbols = false;
506 /* Table mapping type DIEs to their struct type *.
507 This is NULL if not allocated yet.
508 The mapping is done via (CU/TU + DIE offset) -> type. */
509 htab_t die_type_hash {};
511 /* The CUs we recently read. */
512 VEC (dwarf2_per_cu_ptr) *just_read_cus = NULL;
514 /* Table containing line_header indexed by offset and offset_in_dwz. */
515 htab_t line_header_hash {};
517 /* Table containing all filenames. This is an optional because the
518 table is lazily constructed on first access. */
519 gdb::optional<filename_seen_cache> filenames_cache;
522 /* Get the dwarf2_per_objfile associated to OBJFILE. */
524 struct dwarf2_per_objfile *
525 get_dwarf2_per_objfile (struct objfile *objfile)
527 return ((struct dwarf2_per_objfile *)
528 objfile_data (objfile, dwarf2_objfile_data_key));
531 /* Set the dwarf2_per_objfile associated to OBJFILE. */
534 set_dwarf2_per_objfile (struct objfile *objfile,
535 struct dwarf2_per_objfile *dwarf2_per_objfile)
537 gdb_assert (get_dwarf2_per_objfile (objfile) == NULL);
538 set_objfile_data (objfile, dwarf2_objfile_data_key, dwarf2_per_objfile);
541 /* Default names of the debugging sections. */
543 /* Note that if the debugging section has been compressed, it might
544 have a name like .zdebug_info. */
546 static const struct dwarf2_debug_sections dwarf2_elf_names =
548 { ".debug_info", ".zdebug_info" },
549 { ".debug_abbrev", ".zdebug_abbrev" },
550 { ".debug_line", ".zdebug_line" },
551 { ".debug_loc", ".zdebug_loc" },
552 { ".debug_loclists", ".zdebug_loclists" },
553 { ".debug_macinfo", ".zdebug_macinfo" },
554 { ".debug_macro", ".zdebug_macro" },
555 { ".debug_str", ".zdebug_str" },
556 { ".debug_line_str", ".zdebug_line_str" },
557 { ".debug_ranges", ".zdebug_ranges" },
558 { ".debug_rnglists", ".zdebug_rnglists" },
559 { ".debug_types", ".zdebug_types" },
560 { ".debug_addr", ".zdebug_addr" },
561 { ".debug_frame", ".zdebug_frame" },
562 { ".eh_frame", NULL },
563 { ".gdb_index", ".zgdb_index" },
564 { ".debug_names", ".zdebug_names" },
565 { ".debug_aranges", ".zdebug_aranges" },
569 /* List of DWO/DWP sections. */
571 static const struct dwop_section_names
573 struct dwarf2_section_names abbrev_dwo;
574 struct dwarf2_section_names info_dwo;
575 struct dwarf2_section_names line_dwo;
576 struct dwarf2_section_names loc_dwo;
577 struct dwarf2_section_names loclists_dwo;
578 struct dwarf2_section_names macinfo_dwo;
579 struct dwarf2_section_names macro_dwo;
580 struct dwarf2_section_names str_dwo;
581 struct dwarf2_section_names str_offsets_dwo;
582 struct dwarf2_section_names types_dwo;
583 struct dwarf2_section_names cu_index;
584 struct dwarf2_section_names tu_index;
588 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
589 { ".debug_info.dwo", ".zdebug_info.dwo" },
590 { ".debug_line.dwo", ".zdebug_line.dwo" },
591 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
592 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
593 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
594 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
595 { ".debug_str.dwo", ".zdebug_str.dwo" },
596 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
597 { ".debug_types.dwo", ".zdebug_types.dwo" },
598 { ".debug_cu_index", ".zdebug_cu_index" },
599 { ".debug_tu_index", ".zdebug_tu_index" },
602 /* local data types */
604 /* The data in a compilation unit header, after target2host
605 translation, looks like this. */
606 struct comp_unit_head
610 unsigned char addr_size;
611 unsigned char signed_addr_p;
612 sect_offset abbrev_sect_off;
614 /* Size of file offsets; either 4 or 8. */
615 unsigned int offset_size;
617 /* Size of the length field; either 4 or 12. */
618 unsigned int initial_length_size;
620 enum dwarf_unit_type unit_type;
622 /* Offset to the first byte of this compilation unit header in the
623 .debug_info section, for resolving relative reference dies. */
624 sect_offset sect_off;
626 /* Offset to first die in this cu from the start of the cu.
627 This will be the first byte following the compilation unit header. */
628 cu_offset first_die_cu_offset;
630 /* 64-bit signature of this type unit - it is valid only for
631 UNIT_TYPE DW_UT_type. */
634 /* For types, offset in the type's DIE of the type defined by this TU. */
635 cu_offset type_cu_offset_in_tu;
638 /* Type used for delaying computation of method physnames.
639 See comments for compute_delayed_physnames. */
640 struct delayed_method_info
642 /* The type to which the method is attached, i.e., its parent class. */
645 /* The index of the method in the type's function fieldlists. */
648 /* The index of the method in the fieldlist. */
651 /* The name of the DIE. */
654 /* The DIE associated with this method. */
655 struct die_info *die;
658 typedef struct delayed_method_info delayed_method_info;
659 DEF_VEC_O (delayed_method_info);
661 /* Internal state when decoding a particular compilation unit. */
664 /* The header of the compilation unit. */
665 struct comp_unit_head header;
667 /* Base address of this compilation unit. */
668 CORE_ADDR base_address;
670 /* Non-zero if base_address has been set. */
673 /* The language we are debugging. */
674 enum language language;
675 const struct language_defn *language_defn;
677 const char *producer;
679 /* The generic symbol table building routines have separate lists for
680 file scope symbols and all all other scopes (local scopes). So
681 we need to select the right one to pass to add_symbol_to_list().
682 We do it by keeping a pointer to the correct list in list_in_scope.
684 FIXME: The original dwarf code just treated the file scope as the
685 first local scope, and all other local scopes as nested local
686 scopes, and worked fine. Check to see if we really need to
687 distinguish these in buildsym.c. */
688 struct pending **list_in_scope;
690 /* The abbrev table for this CU.
691 Normally this points to the abbrev table in the objfile.
692 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
693 struct abbrev_table *abbrev_table;
695 /* Hash table holding all the loaded partial DIEs
696 with partial_die->offset.SECT_OFF as hash. */
699 /* Storage for things with the same lifetime as this read-in compilation
700 unit, including partial DIEs. */
701 struct obstack comp_unit_obstack;
703 /* When multiple dwarf2_cu structures are living in memory, this field
704 chains them all together, so that they can be released efficiently.
705 We will probably also want a generation counter so that most-recently-used
706 compilation units are cached... */
707 struct dwarf2_per_cu_data *read_in_chain;
709 /* Backlink to our per_cu entry. */
710 struct dwarf2_per_cu_data *per_cu;
712 /* How many compilation units ago was this CU last referenced? */
715 /* A hash table of DIE cu_offset for following references with
716 die_info->offset.sect_off as hash. */
719 /* Full DIEs if read in. */
720 struct die_info *dies;
722 /* A set of pointers to dwarf2_per_cu_data objects for compilation
723 units referenced by this one. Only set during full symbol processing;
724 partial symbol tables do not have dependencies. */
727 /* Header data from the line table, during full symbol processing. */
728 struct line_header *line_header;
729 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
730 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
731 this is the DW_TAG_compile_unit die for this CU. We'll hold on
732 to the line header as long as this DIE is being processed. See
733 process_die_scope. */
734 die_info *line_header_die_owner;
736 /* A list of methods which need to have physnames computed
737 after all type information has been read. */
738 VEC (delayed_method_info) *method_list;
740 /* To be copied to symtab->call_site_htab. */
741 htab_t call_site_htab;
743 /* Non-NULL if this CU came from a DWO file.
744 There is an invariant here that is important to remember:
745 Except for attributes copied from the top level DIE in the "main"
746 (or "stub") file in preparation for reading the DWO file
747 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
748 Either there isn't a DWO file (in which case this is NULL and the point
749 is moot), or there is and either we're not going to read it (in which
750 case this is NULL) or there is and we are reading it (in which case this
752 struct dwo_unit *dwo_unit;
754 /* The DW_AT_addr_base attribute if present, zero otherwise
755 (zero is a valid value though).
756 Note this value comes from the Fission stub CU/TU's DIE. */
759 /* The DW_AT_ranges_base attribute if present, zero otherwise
760 (zero is a valid value though).
761 Note this value comes from the Fission stub CU/TU's DIE.
762 Also note that the value is zero in the non-DWO case so this value can
763 be used without needing to know whether DWO files are in use or not.
764 N.B. This does not apply to DW_AT_ranges appearing in
765 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
766 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
767 DW_AT_ranges_base *would* have to be applied, and we'd have to care
768 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
769 ULONGEST ranges_base;
771 /* Mark used when releasing cached dies. */
772 unsigned int mark : 1;
774 /* This CU references .debug_loc. See the symtab->locations_valid field.
775 This test is imperfect as there may exist optimized debug code not using
776 any location list and still facing inlining issues if handled as
777 unoptimized code. For a future better test see GCC PR other/32998. */
778 unsigned int has_loclist : 1;
780 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
781 if all the producer_is_* fields are valid. This information is cached
782 because profiling CU expansion showed excessive time spent in
783 producer_is_gxx_lt_4_6. */
784 unsigned int checked_producer : 1;
785 unsigned int producer_is_gxx_lt_4_6 : 1;
786 unsigned int producer_is_gcc_lt_4_3 : 1;
787 unsigned int producer_is_icc_lt_14 : 1;
789 /* When set, the file that we're processing is known to have
790 debugging info for C++ namespaces. GCC 3.3.x did not produce
791 this information, but later versions do. */
793 unsigned int processing_has_namespace_info : 1;
796 /* Persistent data held for a compilation unit, even when not
797 processing it. We put a pointer to this structure in the
798 read_symtab_private field of the psymtab. */
800 struct dwarf2_per_cu_data
802 /* The start offset and length of this compilation unit.
803 NOTE: Unlike comp_unit_head.length, this length includes
805 If the DIE refers to a DWO file, this is always of the original die,
807 sect_offset sect_off;
810 /* DWARF standard version this data has been read from (such as 4 or 5). */
813 /* Flag indicating this compilation unit will be read in before
814 any of the current compilation units are processed. */
815 unsigned int queued : 1;
817 /* This flag will be set when reading partial DIEs if we need to load
818 absolutely all DIEs for this compilation unit, instead of just the ones
819 we think are interesting. It gets set if we look for a DIE in the
820 hash table and don't find it. */
821 unsigned int load_all_dies : 1;
823 /* Non-zero if this CU is from .debug_types.
824 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
826 unsigned int is_debug_types : 1;
828 /* Non-zero if this CU is from the .dwz file. */
829 unsigned int is_dwz : 1;
831 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
832 This flag is only valid if is_debug_types is true.
833 We can't read a CU directly from a DWO file: There are required
834 attributes in the stub. */
835 unsigned int reading_dwo_directly : 1;
837 /* Non-zero if the TU has been read.
838 This is used to assist the "Stay in DWO Optimization" for Fission:
839 When reading a DWO, it's faster to read TUs from the DWO instead of
840 fetching them from random other DWOs (due to comdat folding).
841 If the TU has already been read, the optimization is unnecessary
842 (and unwise - we don't want to change where gdb thinks the TU lives
844 This flag is only valid if is_debug_types is true. */
845 unsigned int tu_read : 1;
847 /* The section this CU/TU lives in.
848 If the DIE refers to a DWO file, this is always the original die,
850 struct dwarf2_section_info *section;
852 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
853 of the CU cache it gets reset to NULL again. This is left as NULL for
854 dummy CUs (a CU header, but nothing else). */
855 struct dwarf2_cu *cu;
857 /* The corresponding dwarf2_per_objfile. */
858 struct dwarf2_per_objfile *dwarf2_per_objfile;
860 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
861 is active. Otherwise, the 'psymtab' field is active. */
864 /* The partial symbol table associated with this compilation unit,
865 or NULL for unread partial units. */
866 struct partial_symtab *psymtab;
868 /* Data needed by the "quick" functions. */
869 struct dwarf2_per_cu_quick_data *quick;
872 /* The CUs we import using DW_TAG_imported_unit. This is filled in
873 while reading psymtabs, used to compute the psymtab dependencies,
874 and then cleared. Then it is filled in again while reading full
875 symbols, and only deleted when the objfile is destroyed.
877 This is also used to work around a difference between the way gold
878 generates .gdb_index version <=7 and the way gdb does. Arguably this
879 is a gold bug. For symbols coming from TUs, gold records in the index
880 the CU that includes the TU instead of the TU itself. This breaks
881 dw2_lookup_symbol: It assumes that if the index says symbol X lives
882 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
883 will find X. Alas TUs live in their own symtab, so after expanding CU Y
884 we need to look in TU Z to find X. Fortunately, this is akin to
885 DW_TAG_imported_unit, so we just use the same mechanism: For
886 .gdb_index version <=7 this also records the TUs that the CU referred
887 to. Concurrently with this change gdb was modified to emit version 8
888 indices so we only pay a price for gold generated indices.
889 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
890 VEC (dwarf2_per_cu_ptr) *imported_symtabs;
893 /* Entry in the signatured_types hash table. */
895 struct signatured_type
897 /* The "per_cu" object of this type.
898 This struct is used iff per_cu.is_debug_types.
899 N.B.: This is the first member so that it's easy to convert pointers
901 struct dwarf2_per_cu_data per_cu;
903 /* The type's signature. */
906 /* Offset in the TU of the type's DIE, as read from the TU header.
907 If this TU is a DWO stub and the definition lives in a DWO file
908 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
909 cu_offset type_offset_in_tu;
911 /* Offset in the section of the type's DIE.
912 If the definition lives in a DWO file, this is the offset in the
913 .debug_types.dwo section.
914 The value is zero until the actual value is known.
915 Zero is otherwise not a valid section offset. */
916 sect_offset type_offset_in_section;
918 /* Type units are grouped by their DW_AT_stmt_list entry so that they
919 can share them. This points to the containing symtab. */
920 struct type_unit_group *type_unit_group;
923 The first time we encounter this type we fully read it in and install it
924 in the symbol tables. Subsequent times we only need the type. */
927 /* Containing DWO unit.
928 This field is valid iff per_cu.reading_dwo_directly. */
929 struct dwo_unit *dwo_unit;
932 typedef struct signatured_type *sig_type_ptr;
933 DEF_VEC_P (sig_type_ptr);
935 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
936 This includes type_unit_group and quick_file_names. */
938 struct stmt_list_hash
940 /* The DWO unit this table is from or NULL if there is none. */
941 struct dwo_unit *dwo_unit;
943 /* Offset in .debug_line or .debug_line.dwo. */
944 sect_offset line_sect_off;
947 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
948 an object of this type. */
950 struct type_unit_group
952 /* dwarf2read.c's main "handle" on a TU symtab.
953 To simplify things we create an artificial CU that "includes" all the
954 type units using this stmt_list so that the rest of the code still has
955 a "per_cu" handle on the symtab.
956 This PER_CU is recognized by having no section. */
957 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
958 struct dwarf2_per_cu_data per_cu;
960 /* The TUs that share this DW_AT_stmt_list entry.
961 This is added to while parsing type units to build partial symtabs,
962 and is deleted afterwards and not used again. */
963 VEC (sig_type_ptr) *tus;
965 /* The compunit symtab.
966 Type units in a group needn't all be defined in the same source file,
967 so we create an essentially anonymous symtab as the compunit symtab. */
968 struct compunit_symtab *compunit_symtab;
970 /* The data used to construct the hash key. */
971 struct stmt_list_hash hash;
973 /* The number of symtabs from the line header.
974 The value here must match line_header.num_file_names. */
975 unsigned int num_symtabs;
977 /* The symbol tables for this TU (obtained from the files listed in
979 WARNING: The order of entries here must match the order of entries
980 in the line header. After the first TU using this type_unit_group, the
981 line header for the subsequent TUs is recreated from this. This is done
982 because we need to use the same symtabs for each TU using the same
983 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
984 there's no guarantee the line header doesn't have duplicate entries. */
985 struct symtab **symtabs;
988 /* These sections are what may appear in a (real or virtual) DWO file. */
992 struct dwarf2_section_info abbrev;
993 struct dwarf2_section_info line;
994 struct dwarf2_section_info loc;
995 struct dwarf2_section_info loclists;
996 struct dwarf2_section_info macinfo;
997 struct dwarf2_section_info macro;
998 struct dwarf2_section_info str;
999 struct dwarf2_section_info str_offsets;
1000 /* In the case of a virtual DWO file, these two are unused. */
1001 struct dwarf2_section_info info;
1002 VEC (dwarf2_section_info_def) *types;
1005 /* CUs/TUs in DWP/DWO files. */
1009 /* Backlink to the containing struct dwo_file. */
1010 struct dwo_file *dwo_file;
1012 /* The "id" that distinguishes this CU/TU.
1013 .debug_info calls this "dwo_id", .debug_types calls this "signature".
1014 Since signatures came first, we stick with it for consistency. */
1017 /* The section this CU/TU lives in, in the DWO file. */
1018 struct dwarf2_section_info *section;
1020 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
1021 sect_offset sect_off;
1022 unsigned int length;
1024 /* For types, offset in the type's DIE of the type defined by this TU. */
1025 cu_offset type_offset_in_tu;
1028 /* include/dwarf2.h defines the DWP section codes.
1029 It defines a max value but it doesn't define a min value, which we
1030 use for error checking, so provide one. */
1032 enum dwp_v2_section_ids
1037 /* Data for one DWO file.
1039 This includes virtual DWO files (a virtual DWO file is a DWO file as it
1040 appears in a DWP file). DWP files don't really have DWO files per se -
1041 comdat folding of types "loses" the DWO file they came from, and from
1042 a high level view DWP files appear to contain a mass of random types.
1043 However, to maintain consistency with the non-DWP case we pretend DWP
1044 files contain virtual DWO files, and we assign each TU with one virtual
1045 DWO file (generally based on the line and abbrev section offsets -
1046 a heuristic that seems to work in practice). */
1050 /* The DW_AT_GNU_dwo_name attribute.
1051 For virtual DWO files the name is constructed from the section offsets
1052 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
1053 from related CU+TUs. */
1054 const char *dwo_name;
1056 /* The DW_AT_comp_dir attribute. */
1057 const char *comp_dir;
1059 /* The bfd, when the file is open. Otherwise this is NULL.
1060 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
1063 /* The sections that make up this DWO file.
1064 Remember that for virtual DWO files in DWP V2, these are virtual
1065 sections (for lack of a better name). */
1066 struct dwo_sections sections;
1068 /* The CUs in the file.
1069 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
1070 an extension to handle LLVM's Link Time Optimization output (where
1071 multiple source files may be compiled into a single object/dwo pair). */
1074 /* Table of TUs in the file.
1075 Each element is a struct dwo_unit. */
1079 /* These sections are what may appear in a DWP file. */
1083 /* These are used by both DWP version 1 and 2. */
1084 struct dwarf2_section_info str;
1085 struct dwarf2_section_info cu_index;
1086 struct dwarf2_section_info tu_index;
1088 /* These are only used by DWP version 2 files.
1089 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
1090 sections are referenced by section number, and are not recorded here.
1091 In DWP version 2 there is at most one copy of all these sections, each
1092 section being (effectively) comprised of the concatenation of all of the
1093 individual sections that exist in the version 1 format.
1094 To keep the code simple we treat each of these concatenated pieces as a
1095 section itself (a virtual section?). */
1096 struct dwarf2_section_info abbrev;
1097 struct dwarf2_section_info info;
1098 struct dwarf2_section_info line;
1099 struct dwarf2_section_info loc;
1100 struct dwarf2_section_info macinfo;
1101 struct dwarf2_section_info macro;
1102 struct dwarf2_section_info str_offsets;
1103 struct dwarf2_section_info types;
1106 /* These sections are what may appear in a virtual DWO file in DWP version 1.
1107 A virtual DWO file is a DWO file as it appears in a DWP file. */
1109 struct virtual_v1_dwo_sections
1111 struct dwarf2_section_info abbrev;
1112 struct dwarf2_section_info line;
1113 struct dwarf2_section_info loc;
1114 struct dwarf2_section_info macinfo;
1115 struct dwarf2_section_info macro;
1116 struct dwarf2_section_info str_offsets;
1117 /* Each DWP hash table entry records one CU or one TU.
1118 That is recorded here, and copied to dwo_unit.section. */
1119 struct dwarf2_section_info info_or_types;
1122 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
1123 In version 2, the sections of the DWO files are concatenated together
1124 and stored in one section of that name. Thus each ELF section contains
1125 several "virtual" sections. */
1127 struct virtual_v2_dwo_sections
1129 bfd_size_type abbrev_offset;
1130 bfd_size_type abbrev_size;
1132 bfd_size_type line_offset;
1133 bfd_size_type line_size;
1135 bfd_size_type loc_offset;
1136 bfd_size_type loc_size;
1138 bfd_size_type macinfo_offset;
1139 bfd_size_type macinfo_size;
1141 bfd_size_type macro_offset;
1142 bfd_size_type macro_size;
1144 bfd_size_type str_offsets_offset;
1145 bfd_size_type str_offsets_size;
1147 /* Each DWP hash table entry records one CU or one TU.
1148 That is recorded here, and copied to dwo_unit.section. */
1149 bfd_size_type info_or_types_offset;
1150 bfd_size_type info_or_types_size;
1153 /* Contents of DWP hash tables. */
1155 struct dwp_hash_table
1157 uint32_t version, nr_columns;
1158 uint32_t nr_units, nr_slots;
1159 const gdb_byte *hash_table, *unit_table;
1164 const gdb_byte *indices;
1168 /* This is indexed by column number and gives the id of the section
1170 #define MAX_NR_V2_DWO_SECTIONS \
1171 (1 /* .debug_info or .debug_types */ \
1172 + 1 /* .debug_abbrev */ \
1173 + 1 /* .debug_line */ \
1174 + 1 /* .debug_loc */ \
1175 + 1 /* .debug_str_offsets */ \
1176 + 1 /* .debug_macro or .debug_macinfo */)
1177 int section_ids[MAX_NR_V2_DWO_SECTIONS];
1178 const gdb_byte *offsets;
1179 const gdb_byte *sizes;
1184 /* Data for one DWP file. */
1188 /* Name of the file. */
1191 /* File format version. */
1197 /* Section info for this file. */
1198 struct dwp_sections sections;
1200 /* Table of CUs in the file. */
1201 const struct dwp_hash_table *cus;
1203 /* Table of TUs in the file. */
1204 const struct dwp_hash_table *tus;
1206 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
1210 /* Table to map ELF section numbers to their sections.
1211 This is only needed for the DWP V1 file format. */
1212 unsigned int num_sections;
1213 asection **elf_sections;
1216 /* This represents a '.dwz' file. */
1220 /* A dwz file can only contain a few sections. */
1221 struct dwarf2_section_info abbrev;
1222 struct dwarf2_section_info info;
1223 struct dwarf2_section_info str;
1224 struct dwarf2_section_info line;
1225 struct dwarf2_section_info macro;
1226 struct dwarf2_section_info gdb_index;
1227 struct dwarf2_section_info debug_names;
1229 /* The dwz's BFD. */
1233 /* Struct used to pass misc. parameters to read_die_and_children, et
1234 al. which are used for both .debug_info and .debug_types dies.
1235 All parameters here are unchanging for the life of the call. This
1236 struct exists to abstract away the constant parameters of die reading. */
1238 struct die_reader_specs
1240 /* The bfd of die_section. */
1243 /* The CU of the DIE we are parsing. */
1244 struct dwarf2_cu *cu;
1246 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1247 struct dwo_file *dwo_file;
1249 /* The section the die comes from.
1250 This is either .debug_info or .debug_types, or the .dwo variants. */
1251 struct dwarf2_section_info *die_section;
1253 /* die_section->buffer. */
1254 const gdb_byte *buffer;
1256 /* The end of the buffer. */
1257 const gdb_byte *buffer_end;
1259 /* The value of the DW_AT_comp_dir attribute. */
1260 const char *comp_dir;
1263 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1264 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
1265 const gdb_byte *info_ptr,
1266 struct die_info *comp_unit_die,
1270 /* A 1-based directory index. This is a strong typedef to prevent
1271 accidentally using a directory index as a 0-based index into an
1273 enum class dir_index : unsigned int {};
1275 /* Likewise, a 1-based file name index. */
1276 enum class file_name_index : unsigned int {};
1280 file_entry () = default;
1282 file_entry (const char *name_, dir_index d_index_,
1283 unsigned int mod_time_, unsigned int length_)
1286 mod_time (mod_time_),
1290 /* Return the include directory at D_INDEX stored in LH. Returns
1291 NULL if D_INDEX is out of bounds. */
1292 const char *include_dir (const line_header *lh) const;
1294 /* The file name. Note this is an observing pointer. The memory is
1295 owned by debug_line_buffer. */
1296 const char *name {};
1298 /* The directory index (1-based). */
1299 dir_index d_index {};
1301 unsigned int mod_time {};
1303 unsigned int length {};
1305 /* True if referenced by the Line Number Program. */
1308 /* The associated symbol table, if any. */
1309 struct symtab *symtab {};
1312 /* The line number information for a compilation unit (found in the
1313 .debug_line section) begins with a "statement program header",
1314 which contains the following information. */
1321 /* Add an entry to the include directory table. */
1322 void add_include_dir (const char *include_dir);
1324 /* Add an entry to the file name table. */
1325 void add_file_name (const char *name, dir_index d_index,
1326 unsigned int mod_time, unsigned int length);
1328 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
1329 is out of bounds. */
1330 const char *include_dir_at (dir_index index) const
1332 /* Convert directory index number (1-based) to vector index
1334 size_t vec_index = to_underlying (index) - 1;
1336 if (vec_index >= include_dirs.size ())
1338 return include_dirs[vec_index];
1341 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
1342 is out of bounds. */
1343 file_entry *file_name_at (file_name_index index)
1345 /* Convert file name index number (1-based) to vector index
1347 size_t vec_index = to_underlying (index) - 1;
1349 if (vec_index >= file_names.size ())
1351 return &file_names[vec_index];
1354 /* Const version of the above. */
1355 const file_entry *file_name_at (unsigned int index) const
1357 if (index >= file_names.size ())
1359 return &file_names[index];
1362 /* Offset of line number information in .debug_line section. */
1363 sect_offset sect_off {};
1365 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1366 unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class. */
1368 unsigned int total_length {};
1369 unsigned short version {};
1370 unsigned int header_length {};
1371 unsigned char minimum_instruction_length {};
1372 unsigned char maximum_ops_per_instruction {};
1373 unsigned char default_is_stmt {};
1375 unsigned char line_range {};
1376 unsigned char opcode_base {};
1378 /* standard_opcode_lengths[i] is the number of operands for the
1379 standard opcode whose value is i. This means that
1380 standard_opcode_lengths[0] is unused, and the last meaningful
1381 element is standard_opcode_lengths[opcode_base - 1]. */
1382 std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1384 /* The include_directories table. Note these are observing
1385 pointers. The memory is owned by debug_line_buffer. */
1386 std::vector<const char *> include_dirs;
1388 /* The file_names table. */
1389 std::vector<file_entry> file_names;
1391 /* The start and end of the statement program following this
1392 header. These point into dwarf2_per_objfile->line_buffer. */
1393 const gdb_byte *statement_program_start {}, *statement_program_end {};
1396 typedef std::unique_ptr<line_header> line_header_up;
1399 file_entry::include_dir (const line_header *lh) const
1401 return lh->include_dir_at (d_index);
1404 /* When we construct a partial symbol table entry we only
1405 need this much information. */
1406 struct partial_die_info
1408 /* Offset of this DIE. */
1409 sect_offset sect_off;
1411 /* DWARF-2 tag for this DIE. */
1412 ENUM_BITFIELD(dwarf_tag) tag : 16;
1414 /* Assorted flags describing the data found in this DIE. */
1415 unsigned int has_children : 1;
1416 unsigned int is_external : 1;
1417 unsigned int is_declaration : 1;
1418 unsigned int has_type : 1;
1419 unsigned int has_specification : 1;
1420 unsigned int has_pc_info : 1;
1421 unsigned int may_be_inlined : 1;
1423 /* This DIE has been marked DW_AT_main_subprogram. */
1424 unsigned int main_subprogram : 1;
1426 /* Flag set if the SCOPE field of this structure has been
1428 unsigned int scope_set : 1;
1430 /* Flag set if the DIE has a byte_size attribute. */
1431 unsigned int has_byte_size : 1;
1433 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1434 unsigned int has_const_value : 1;
1436 /* Flag set if any of the DIE's children are template arguments. */
1437 unsigned int has_template_arguments : 1;
1439 /* Flag set if fixup_partial_die has been called on this die. */
1440 unsigned int fixup_called : 1;
1442 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1443 unsigned int is_dwz : 1;
1445 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1446 unsigned int spec_is_dwz : 1;
1448 /* The name of this DIE. Normally the value of DW_AT_name, but
1449 sometimes a default name for unnamed DIEs. */
1452 /* The linkage name, if present. */
1453 const char *linkage_name;
1455 /* The scope to prepend to our children. This is generally
1456 allocated on the comp_unit_obstack, so will disappear
1457 when this compilation unit leaves the cache. */
1460 /* Some data associated with the partial DIE. The tag determines
1461 which field is live. */
1464 /* The location description associated with this DIE, if any. */
1465 struct dwarf_block *locdesc;
1466 /* The offset of an import, for DW_TAG_imported_unit. */
1467 sect_offset sect_off;
1470 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1474 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1475 DW_AT_sibling, if any. */
1476 /* NOTE: This member isn't strictly necessary, read_partial_die could
1477 return DW_AT_sibling values to its caller load_partial_dies. */
1478 const gdb_byte *sibling;
1480 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1481 DW_AT_specification (or DW_AT_abstract_origin or
1482 DW_AT_extension). */
1483 sect_offset spec_offset;
1485 /* Pointers to this DIE's parent, first child, and next sibling,
1487 struct partial_die_info *die_parent, *die_child, *die_sibling;
1490 /* This data structure holds the information of an abbrev. */
1493 unsigned int number; /* number identifying abbrev */
1494 enum dwarf_tag tag; /* dwarf tag */
1495 unsigned short has_children; /* boolean */
1496 unsigned short num_attrs; /* number of attributes */
1497 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1498 struct abbrev_info *next; /* next in chain */
1503 ENUM_BITFIELD(dwarf_attribute) name : 16;
1504 ENUM_BITFIELD(dwarf_form) form : 16;
1506 /* It is valid only if FORM is DW_FORM_implicit_const. */
1507 LONGEST implicit_const;
1510 /* Size of abbrev_table.abbrev_hash_table. */
1511 #define ABBREV_HASH_SIZE 121
1513 /* Top level data structure to contain an abbreviation table. */
1517 /* Where the abbrev table came from.
1518 This is used as a sanity check when the table is used. */
1519 sect_offset sect_off;
1521 /* Storage for the abbrev table. */
1522 struct obstack abbrev_obstack;
1524 /* Hash table of abbrevs.
1525 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1526 It could be statically allocated, but the previous code didn't so we
1528 struct abbrev_info **abbrevs;
1531 /* Attributes have a name and a value. */
1534 ENUM_BITFIELD(dwarf_attribute) name : 16;
1535 ENUM_BITFIELD(dwarf_form) form : 15;
1537 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1538 field should be in u.str (existing only for DW_STRING) but it is kept
1539 here for better struct attribute alignment. */
1540 unsigned int string_is_canonical : 1;
1545 struct dwarf_block *blk;
1554 /* This data structure holds a complete die structure. */
1557 /* DWARF-2 tag for this DIE. */
1558 ENUM_BITFIELD(dwarf_tag) tag : 16;
1560 /* Number of attributes */
1561 unsigned char num_attrs;
1563 /* True if we're presently building the full type name for the
1564 type derived from this DIE. */
1565 unsigned char building_fullname : 1;
1567 /* True if this die is in process. PR 16581. */
1568 unsigned char in_process : 1;
1571 unsigned int abbrev;
1573 /* Offset in .debug_info or .debug_types section. */
1574 sect_offset sect_off;
1576 /* The dies in a compilation unit form an n-ary tree. PARENT
1577 points to this die's parent; CHILD points to the first child of
1578 this node; and all the children of a given node are chained
1579 together via their SIBLING fields. */
1580 struct die_info *child; /* Its first child, if any. */
1581 struct die_info *sibling; /* Its next sibling, if any. */
1582 struct die_info *parent; /* Its parent, if any. */
1584 /* An array of attributes, with NUM_ATTRS elements. There may be
1585 zero, but it's not common and zero-sized arrays are not
1586 sufficiently portable C. */
1587 struct attribute attrs[1];
1590 /* Get at parts of an attribute structure. */
1592 #define DW_STRING(attr) ((attr)->u.str)
1593 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1594 #define DW_UNSND(attr) ((attr)->u.unsnd)
1595 #define DW_BLOCK(attr) ((attr)->u.blk)
1596 #define DW_SND(attr) ((attr)->u.snd)
1597 #define DW_ADDR(attr) ((attr)->u.addr)
1598 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1600 /* Blocks are a bunch of untyped bytes. */
1605 /* Valid only if SIZE is not zero. */
1606 const gdb_byte *data;
1609 #ifndef ATTR_ALLOC_CHUNK
1610 #define ATTR_ALLOC_CHUNK 4
1613 /* Allocate fields for structs, unions and enums in this size. */
1614 #ifndef DW_FIELD_ALLOC_CHUNK
1615 #define DW_FIELD_ALLOC_CHUNK 4
1618 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1619 but this would require a corresponding change in unpack_field_as_long
1621 static int bits_per_byte = 8;
1625 struct nextfield *next;
1633 struct nextfnfield *next;
1634 struct fn_field fnfield;
1641 struct nextfnfield *head;
1644 struct decl_field_list
1646 struct decl_field field;
1647 struct decl_field_list *next;
1650 /* The routines that read and process dies for a C struct or C++ class
1651 pass lists of data member fields and lists of member function fields
1652 in an instance of a field_info structure, as defined below. */
1655 /* List of data member and baseclasses fields. */
1656 struct nextfield *fields, *baseclasses;
1658 /* Number of fields (including baseclasses). */
1661 /* Number of baseclasses. */
1664 /* Set if the accesibility of one of the fields is not public. */
1665 int non_public_fields;
1667 /* Member function fieldlist array, contains name of possibly overloaded
1668 member function, number of overloaded member functions and a pointer
1669 to the head of the member function field chain. */
1670 struct fnfieldlist *fnfieldlists;
1672 /* Number of entries in the fnfieldlists array. */
1675 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1676 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1677 struct decl_field_list *typedef_field_list;
1678 unsigned typedef_field_list_count;
1680 /* Nested types defined by this class and the number of elements in this
1682 struct decl_field_list *nested_types_list;
1683 unsigned nested_types_list_count;
1686 /* One item on the queue of compilation units to read in full symbols
1688 struct dwarf2_queue_item
1690 struct dwarf2_per_cu_data *per_cu;
1691 enum language pretend_language;
1692 struct dwarf2_queue_item *next;
1695 /* The current queue. */
1696 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1698 /* Loaded secondary compilation units are kept in memory until they
1699 have not been referenced for the processing of this many
1700 compilation units. Set this to zero to disable caching. Cache
1701 sizes of up to at least twenty will improve startup time for
1702 typical inter-CU-reference binaries, at an obvious memory cost. */
1703 static int dwarf_max_cache_age = 5;
1705 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1706 struct cmd_list_element *c, const char *value)
1708 fprintf_filtered (file, _("The upper bound on the age of cached "
1709 "DWARF compilation units is %s.\n"),
1713 /* local function prototypes */
1715 static const char *get_section_name (const struct dwarf2_section_info *);
1717 static const char *get_section_file_name (const struct dwarf2_section_info *);
1719 static void dwarf2_find_base_address (struct die_info *die,
1720 struct dwarf2_cu *cu);
1722 static struct partial_symtab *create_partial_symtab
1723 (struct dwarf2_per_cu_data *per_cu, const char *name);
1725 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1726 const gdb_byte *info_ptr,
1727 struct die_info *type_unit_die,
1728 int has_children, void *data);
1730 static void dwarf2_build_psymtabs_hard
1731 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1733 static void scan_partial_symbols (struct partial_die_info *,
1734 CORE_ADDR *, CORE_ADDR *,
1735 int, struct dwarf2_cu *);
1737 static void add_partial_symbol (struct partial_die_info *,
1738 struct dwarf2_cu *);
1740 static void add_partial_namespace (struct partial_die_info *pdi,
1741 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1742 int set_addrmap, struct dwarf2_cu *cu);
1744 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1745 CORE_ADDR *highpc, int set_addrmap,
1746 struct dwarf2_cu *cu);
1748 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1749 struct dwarf2_cu *cu);
1751 static void add_partial_subprogram (struct partial_die_info *pdi,
1752 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1753 int need_pc, struct dwarf2_cu *cu);
1755 static void dwarf2_read_symtab (struct partial_symtab *,
1758 static void psymtab_to_symtab_1 (struct partial_symtab *);
1760 static struct abbrev_info *abbrev_table_lookup_abbrev
1761 (const struct abbrev_table *, unsigned int);
1763 static struct abbrev_table *abbrev_table_read_table
1764 (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1767 static void abbrev_table_free (struct abbrev_table *);
1769 static void abbrev_table_free_cleanup (void *);
1771 static void dwarf2_read_abbrevs (struct dwarf2_cu *,
1772 struct dwarf2_section_info *);
1774 static void dwarf2_free_abbrev_table (void *);
1776 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1778 static struct partial_die_info *load_partial_dies
1779 (const struct die_reader_specs *, const gdb_byte *, int);
1781 static const gdb_byte *read_partial_die (const struct die_reader_specs *,
1782 struct partial_die_info *,
1783 struct abbrev_info *,
1787 static struct partial_die_info *find_partial_die (sect_offset, int,
1788 struct dwarf2_cu *);
1790 static void fixup_partial_die (struct partial_die_info *,
1791 struct dwarf2_cu *);
1793 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1794 struct attribute *, struct attr_abbrev *,
1797 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1799 static int read_1_signed_byte (bfd *, const gdb_byte *);
1801 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1803 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1805 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1807 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1810 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1812 static LONGEST read_checked_initial_length_and_offset
1813 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1814 unsigned int *, unsigned int *);
1816 static LONGEST read_offset (bfd *, const gdb_byte *,
1817 const struct comp_unit_head *,
1820 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1822 static sect_offset read_abbrev_offset
1823 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1824 struct dwarf2_section_info *, sect_offset);
1826 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1828 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1830 static const char *read_indirect_string
1831 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1832 const struct comp_unit_head *, unsigned int *);
1834 static const char *read_indirect_line_string
1835 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1836 const struct comp_unit_head *, unsigned int *);
1838 static const char *read_indirect_string_at_offset
1839 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1840 LONGEST str_offset);
1842 static const char *read_indirect_string_from_dwz
1843 (struct objfile *objfile, struct dwz_file *, LONGEST);
1845 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1847 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1851 static const char *read_str_index (const struct die_reader_specs *reader,
1852 ULONGEST str_index);
1854 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1856 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1857 struct dwarf2_cu *);
1859 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1862 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1863 struct dwarf2_cu *cu);
1865 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1866 struct dwarf2_cu *cu);
1868 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1870 static struct die_info *die_specification (struct die_info *die,
1871 struct dwarf2_cu **);
1873 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1874 struct dwarf2_cu *cu);
1876 static void dwarf_decode_lines (struct line_header *, const char *,
1877 struct dwarf2_cu *, struct partial_symtab *,
1878 CORE_ADDR, int decode_mapping);
1880 static void dwarf2_start_subfile (const char *, const char *);
1882 static struct compunit_symtab *dwarf2_start_symtab (struct dwarf2_cu *,
1883 const char *, const char *,
1886 static struct symbol *new_symbol (struct die_info *, struct type *,
1887 struct dwarf2_cu *, struct symbol * = NULL);
1889 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1890 struct dwarf2_cu *);
1892 static void dwarf2_const_value_attr (const struct attribute *attr,
1895 struct obstack *obstack,
1896 struct dwarf2_cu *cu, LONGEST *value,
1897 const gdb_byte **bytes,
1898 struct dwarf2_locexpr_baton **baton);
1900 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1902 static int need_gnat_info (struct dwarf2_cu *);
1904 static struct type *die_descriptive_type (struct die_info *,
1905 struct dwarf2_cu *);
1907 static void set_descriptive_type (struct type *, struct die_info *,
1908 struct dwarf2_cu *);
1910 static struct type *die_containing_type (struct die_info *,
1911 struct dwarf2_cu *);
1913 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1914 struct dwarf2_cu *);
1916 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1918 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1920 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1922 static char *typename_concat (struct obstack *obs, const char *prefix,
1923 const char *suffix, int physname,
1924 struct dwarf2_cu *cu);
1926 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1928 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1930 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1932 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1934 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1936 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1938 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1939 struct dwarf2_cu *, struct partial_symtab *);
1941 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1942 values. Keep the items ordered with increasing constraints compliance. */
1945 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1946 PC_BOUNDS_NOT_PRESENT,
1948 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1949 were present but they do not form a valid range of PC addresses. */
1952 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1955 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1959 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1960 CORE_ADDR *, CORE_ADDR *,
1962 struct partial_symtab *);
1964 static void get_scope_pc_bounds (struct die_info *,
1965 CORE_ADDR *, CORE_ADDR *,
1966 struct dwarf2_cu *);
1968 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1969 CORE_ADDR, struct dwarf2_cu *);
1971 static void dwarf2_add_field (struct field_info *, struct die_info *,
1972 struct dwarf2_cu *);
1974 static void dwarf2_attach_fields_to_type (struct field_info *,
1975 struct type *, struct dwarf2_cu *);
1977 static void dwarf2_add_member_fn (struct field_info *,
1978 struct die_info *, struct type *,
1979 struct dwarf2_cu *);
1981 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1983 struct dwarf2_cu *);
1985 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1987 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1989 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1991 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1993 static struct using_direct **using_directives (enum language);
1995 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1997 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1999 static struct type *read_module_type (struct die_info *die,
2000 struct dwarf2_cu *cu);
2002 static const char *namespace_name (struct die_info *die,
2003 int *is_anonymous, struct dwarf2_cu *);
2005 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
2007 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
2009 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
2010 struct dwarf2_cu *);
2012 static struct die_info *read_die_and_siblings_1
2013 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
2016 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
2017 const gdb_byte *info_ptr,
2018 const gdb_byte **new_info_ptr,
2019 struct die_info *parent);
2021 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
2022 struct die_info **, const gdb_byte *,
2025 static const gdb_byte *read_full_die (const struct die_reader_specs *,
2026 struct die_info **, const gdb_byte *,
2029 static void process_die (struct die_info *, struct dwarf2_cu *);
2031 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
2034 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
2036 static const char *dwarf2_full_name (const char *name,
2037 struct die_info *die,
2038 struct dwarf2_cu *cu);
2040 static const char *dwarf2_physname (const char *name, struct die_info *die,
2041 struct dwarf2_cu *cu);
2043 static struct die_info *dwarf2_extension (struct die_info *die,
2044 struct dwarf2_cu **);
2046 static const char *dwarf_tag_name (unsigned int);
2048 static const char *dwarf_attr_name (unsigned int);
2050 static const char *dwarf_form_name (unsigned int);
2052 static const char *dwarf_bool_name (unsigned int);
2054 static const char *dwarf_type_encoding_name (unsigned int);
2056 static struct die_info *sibling_die (struct die_info *);
2058 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
2060 static void dump_die_for_error (struct die_info *);
2062 static void dump_die_1 (struct ui_file *, int level, int max_level,
2065 /*static*/ void dump_die (struct die_info *, int max_level);
2067 static void store_in_ref_table (struct die_info *,
2068 struct dwarf2_cu *);
2070 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
2072 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
2074 static struct die_info *follow_die_ref_or_sig (struct die_info *,
2075 const struct attribute *,
2076 struct dwarf2_cu **);
2078 static struct die_info *follow_die_ref (struct die_info *,
2079 const struct attribute *,
2080 struct dwarf2_cu **);
2082 static struct die_info *follow_die_sig (struct die_info *,
2083 const struct attribute *,
2084 struct dwarf2_cu **);
2086 static struct type *get_signatured_type (struct die_info *, ULONGEST,
2087 struct dwarf2_cu *);
2089 static struct type *get_DW_AT_signature_type (struct die_info *,
2090 const struct attribute *,
2091 struct dwarf2_cu *);
2093 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
2095 static void read_signatured_type (struct signatured_type *);
2097 static int attr_to_dynamic_prop (const struct attribute *attr,
2098 struct die_info *die, struct dwarf2_cu *cu,
2099 struct dynamic_prop *prop);
2101 /* memory allocation interface */
2103 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
2105 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
2107 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
2109 static int attr_form_is_block (const struct attribute *);
2111 static int attr_form_is_section_offset (const struct attribute *);
2113 static int attr_form_is_constant (const struct attribute *);
2115 static int attr_form_is_ref (const struct attribute *);
2117 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
2118 struct dwarf2_loclist_baton *baton,
2119 const struct attribute *attr);
2121 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
2123 struct dwarf2_cu *cu,
2126 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
2127 const gdb_byte *info_ptr,
2128 struct abbrev_info *abbrev);
2130 static void free_stack_comp_unit (void *);
2132 static hashval_t partial_die_hash (const void *item);
2134 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
2136 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
2137 (sect_offset sect_off, unsigned int offset_in_dwz,
2138 struct dwarf2_per_objfile *dwarf2_per_objfile);
2140 static void init_one_comp_unit (struct dwarf2_cu *cu,
2141 struct dwarf2_per_cu_data *per_cu);
2143 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
2144 struct die_info *comp_unit_die,
2145 enum language pretend_language);
2147 static void free_heap_comp_unit (void *);
2149 static void free_cached_comp_units (void *);
2151 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
2153 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
2155 static struct type *set_die_type (struct die_info *, struct type *,
2156 struct dwarf2_cu *);
2158 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
2160 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
2162 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
2165 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
2168 static void process_full_type_unit (struct dwarf2_per_cu_data *,
2171 static void dwarf2_add_dependence (struct dwarf2_cu *,
2172 struct dwarf2_per_cu_data *);
2174 static void dwarf2_mark (struct dwarf2_cu *);
2176 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
2178 static struct type *get_die_type_at_offset (sect_offset,
2179 struct dwarf2_per_cu_data *);
2181 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
2183 static void dwarf2_release_queue (void *dummy);
2185 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
2186 enum language pretend_language);
2188 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
2190 /* The return type of find_file_and_directory. Note, the enclosed
2191 string pointers are only valid while this object is valid. */
2193 struct file_and_directory
2195 /* The filename. This is never NULL. */
2198 /* The compilation directory. NULL if not known. If we needed to
2199 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
2200 points directly to the DW_AT_comp_dir string attribute owned by
2201 the obstack that owns the DIE. */
2202 const char *comp_dir;
2204 /* If we needed to build a new string for comp_dir, this is what
2205 owns the storage. */
2206 std::string comp_dir_storage;
2209 static file_and_directory find_file_and_directory (struct die_info *die,
2210 struct dwarf2_cu *cu);
2212 static char *file_full_name (int file, struct line_header *lh,
2213 const char *comp_dir);
2215 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
2216 enum class rcuh_kind { COMPILE, TYPE };
2218 static const gdb_byte *read_and_check_comp_unit_head
2219 (struct dwarf2_per_objfile* dwarf2_per_objfile,
2220 struct comp_unit_head *header,
2221 struct dwarf2_section_info *section,
2222 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
2223 rcuh_kind section_kind);
2225 static void init_cutu_and_read_dies
2226 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
2227 int use_existing_cu, int keep,
2228 die_reader_func_ftype *die_reader_func, void *data);
2230 static void init_cutu_and_read_dies_simple
2231 (struct dwarf2_per_cu_data *this_cu,
2232 die_reader_func_ftype *die_reader_func, void *data);
2234 static htab_t allocate_signatured_type_table (struct objfile *objfile);
2236 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
2238 static struct dwo_unit *lookup_dwo_unit_in_dwp
2239 (struct dwarf2_per_objfile *dwarf2_per_objfile,
2240 struct dwp_file *dwp_file, const char *comp_dir,
2241 ULONGEST signature, int is_debug_types);
2243 static struct dwp_file *get_dwp_file
2244 (struct dwarf2_per_objfile *dwarf2_per_objfile);
2246 static struct dwo_unit *lookup_dwo_comp_unit
2247 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
2249 static struct dwo_unit *lookup_dwo_type_unit
2250 (struct signatured_type *, const char *, const char *);
2252 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
2254 static void free_dwo_file_cleanup (void *);
2256 struct free_dwo_file_cleanup_data
2258 struct dwo_file *dwo_file;
2259 struct dwarf2_per_objfile *dwarf2_per_objfile;
2262 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2264 static void check_producer (struct dwarf2_cu *cu);
2266 static void free_line_header_voidp (void *arg);
2268 /* Various complaints about symbol reading that don't abort the process. */
2271 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2273 complaint (&symfile_complaints,
2274 _("statement list doesn't fit in .debug_line section"));
2278 dwarf2_debug_line_missing_file_complaint (void)
2280 complaint (&symfile_complaints,
2281 _(".debug_line section has line data without a file"));
2285 dwarf2_debug_line_missing_end_sequence_complaint (void)
2287 complaint (&symfile_complaints,
2288 _(".debug_line section has line "
2289 "program sequence without an end"));
2293 dwarf2_complex_location_expr_complaint (void)
2295 complaint (&symfile_complaints, _("location expression too complex"));
2299 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2302 complaint (&symfile_complaints,
2303 _("const value length mismatch for '%s', got %d, expected %d"),
2308 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2310 complaint (&symfile_complaints,
2311 _("debug info runs off end of %s section"
2313 get_section_name (section),
2314 get_section_file_name (section));
2318 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2320 complaint (&symfile_complaints,
2321 _("macro debug info contains a "
2322 "malformed macro definition:\n`%s'"),
2327 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2329 complaint (&symfile_complaints,
2330 _("invalid attribute class or form for '%s' in '%s'"),
2334 /* Hash function for line_header_hash. */
2337 line_header_hash (const struct line_header *ofs)
2339 return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2342 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2345 line_header_hash_voidp (const void *item)
2347 const struct line_header *ofs = (const struct line_header *) item;
2349 return line_header_hash (ofs);
2352 /* Equality function for line_header_hash. */
2355 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2357 const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2358 const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2360 return (ofs_lhs->sect_off == ofs_rhs->sect_off
2361 && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2366 /* Read the given attribute value as an address, taking the attribute's
2367 form into account. */
2370 attr_value_as_address (struct attribute *attr)
2374 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2376 /* Aside from a few clearly defined exceptions, attributes that
2377 contain an address must always be in DW_FORM_addr form.
2378 Unfortunately, some compilers happen to be violating this
2379 requirement by encoding addresses using other forms, such
2380 as DW_FORM_data4 for example. For those broken compilers,
2381 we try to do our best, without any guarantee of success,
2382 to interpret the address correctly. It would also be nice
2383 to generate a complaint, but that would require us to maintain
2384 a list of legitimate cases where a non-address form is allowed,
2385 as well as update callers to pass in at least the CU's DWARF
2386 version. This is more overhead than what we're willing to
2387 expand for a pretty rare case. */
2388 addr = DW_UNSND (attr);
2391 addr = DW_ADDR (attr);
2396 /* The suffix for an index file. */
2397 #define INDEX4_SUFFIX ".gdb-index"
2398 #define INDEX5_SUFFIX ".debug_names"
2399 #define DEBUG_STR_SUFFIX ".debug_str"
2401 /* See declaration. */
2403 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2404 const dwarf2_debug_sections *names)
2405 : objfile (objfile_)
2408 names = &dwarf2_elf_names;
2410 bfd *obfd = objfile->obfd;
2412 for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2413 locate_sections (obfd, sec, *names);
2416 dwarf2_per_objfile::~dwarf2_per_objfile ()
2418 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2419 free_cached_comp_units ();
2421 if (quick_file_names_table)
2422 htab_delete (quick_file_names_table);
2424 if (line_header_hash)
2425 htab_delete (line_header_hash);
2427 /* Everything else should be on the objfile obstack. */
2430 /* See declaration. */
2433 dwarf2_per_objfile::free_cached_comp_units ()
2435 dwarf2_per_cu_data *per_cu = read_in_chain;
2436 dwarf2_per_cu_data **last_chain = &read_in_chain;
2437 while (per_cu != NULL)
2439 dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2441 free_heap_comp_unit (per_cu->cu);
2442 *last_chain = next_cu;
2447 /* Try to locate the sections we need for DWARF 2 debugging
2448 information and return true if we have enough to do something.
2449 NAMES points to the dwarf2 section names, or is NULL if the standard
2450 ELF names are used. */
2453 dwarf2_has_info (struct objfile *objfile,
2454 const struct dwarf2_debug_sections *names)
2456 if (objfile->flags & OBJF_READNEVER)
2459 struct dwarf2_per_objfile *dwarf2_per_objfile
2460 = get_dwarf2_per_objfile (objfile);
2462 if (dwarf2_per_objfile == NULL)
2464 /* Initialize per-objfile state. */
2465 struct dwarf2_per_objfile *data
2466 = XOBNEW (&objfile->objfile_obstack, struct dwarf2_per_objfile);
2468 dwarf2_per_objfile = new (data) struct dwarf2_per_objfile (objfile, names);
2469 set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2471 return (!dwarf2_per_objfile->info.is_virtual
2472 && dwarf2_per_objfile->info.s.section != NULL
2473 && !dwarf2_per_objfile->abbrev.is_virtual
2474 && dwarf2_per_objfile->abbrev.s.section != NULL);
2477 /* Return the containing section of virtual section SECTION. */
2479 static struct dwarf2_section_info *
2480 get_containing_section (const struct dwarf2_section_info *section)
2482 gdb_assert (section->is_virtual);
2483 return section->s.containing_section;
2486 /* Return the bfd owner of SECTION. */
2489 get_section_bfd_owner (const struct dwarf2_section_info *section)
2491 if (section->is_virtual)
2493 section = get_containing_section (section);
2494 gdb_assert (!section->is_virtual);
2496 return section->s.section->owner;
2499 /* Return the bfd section of SECTION.
2500 Returns NULL if the section is not present. */
2503 get_section_bfd_section (const struct dwarf2_section_info *section)
2505 if (section->is_virtual)
2507 section = get_containing_section (section);
2508 gdb_assert (!section->is_virtual);
2510 return section->s.section;
2513 /* Return the name of SECTION. */
2516 get_section_name (const struct dwarf2_section_info *section)
2518 asection *sectp = get_section_bfd_section (section);
2520 gdb_assert (sectp != NULL);
2521 return bfd_section_name (get_section_bfd_owner (section), sectp);
2524 /* Return the name of the file SECTION is in. */
2527 get_section_file_name (const struct dwarf2_section_info *section)
2529 bfd *abfd = get_section_bfd_owner (section);
2531 return bfd_get_filename (abfd);
2534 /* Return the id of SECTION.
2535 Returns 0 if SECTION doesn't exist. */
2538 get_section_id (const struct dwarf2_section_info *section)
2540 asection *sectp = get_section_bfd_section (section);
2547 /* Return the flags of SECTION.
2548 SECTION (or containing section if this is a virtual section) must exist. */
2551 get_section_flags (const struct dwarf2_section_info *section)
2553 asection *sectp = get_section_bfd_section (section);
2555 gdb_assert (sectp != NULL);
2556 return bfd_get_section_flags (sectp->owner, sectp);
2559 /* When loading sections, we look either for uncompressed section or for
2560 compressed section names. */
2563 section_is_p (const char *section_name,
2564 const struct dwarf2_section_names *names)
2566 if (names->normal != NULL
2567 && strcmp (section_name, names->normal) == 0)
2569 if (names->compressed != NULL
2570 && strcmp (section_name, names->compressed) == 0)
2575 /* See declaration. */
2578 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2579 const dwarf2_debug_sections &names)
2581 flagword aflag = bfd_get_section_flags (abfd, sectp);
2583 if ((aflag & SEC_HAS_CONTENTS) == 0)
2586 else if (section_is_p (sectp->name, &names.info))
2588 this->info.s.section = sectp;
2589 this->info.size = bfd_get_section_size (sectp);
2591 else if (section_is_p (sectp->name, &names.abbrev))
2593 this->abbrev.s.section = sectp;
2594 this->abbrev.size = bfd_get_section_size (sectp);
2596 else if (section_is_p (sectp->name, &names.line))
2598 this->line.s.section = sectp;
2599 this->line.size = bfd_get_section_size (sectp);
2601 else if (section_is_p (sectp->name, &names.loc))
2603 this->loc.s.section = sectp;
2604 this->loc.size = bfd_get_section_size (sectp);
2606 else if (section_is_p (sectp->name, &names.loclists))
2608 this->loclists.s.section = sectp;
2609 this->loclists.size = bfd_get_section_size (sectp);
2611 else if (section_is_p (sectp->name, &names.macinfo))
2613 this->macinfo.s.section = sectp;
2614 this->macinfo.size = bfd_get_section_size (sectp);
2616 else if (section_is_p (sectp->name, &names.macro))
2618 this->macro.s.section = sectp;
2619 this->macro.size = bfd_get_section_size (sectp);
2621 else if (section_is_p (sectp->name, &names.str))
2623 this->str.s.section = sectp;
2624 this->str.size = bfd_get_section_size (sectp);
2626 else if (section_is_p (sectp->name, &names.line_str))
2628 this->line_str.s.section = sectp;
2629 this->line_str.size = bfd_get_section_size (sectp);
2631 else if (section_is_p (sectp->name, &names.addr))
2633 this->addr.s.section = sectp;
2634 this->addr.size = bfd_get_section_size (sectp);
2636 else if (section_is_p (sectp->name, &names.frame))
2638 this->frame.s.section = sectp;
2639 this->frame.size = bfd_get_section_size (sectp);
2641 else if (section_is_p (sectp->name, &names.eh_frame))
2643 this->eh_frame.s.section = sectp;
2644 this->eh_frame.size = bfd_get_section_size (sectp);
2646 else if (section_is_p (sectp->name, &names.ranges))
2648 this->ranges.s.section = sectp;
2649 this->ranges.size = bfd_get_section_size (sectp);
2651 else if (section_is_p (sectp->name, &names.rnglists))
2653 this->rnglists.s.section = sectp;
2654 this->rnglists.size = bfd_get_section_size (sectp);
2656 else if (section_is_p (sectp->name, &names.types))
2658 struct dwarf2_section_info type_section;
2660 memset (&type_section, 0, sizeof (type_section));
2661 type_section.s.section = sectp;
2662 type_section.size = bfd_get_section_size (sectp);
2664 VEC_safe_push (dwarf2_section_info_def, this->types,
2667 else if (section_is_p (sectp->name, &names.gdb_index))
2669 this->gdb_index.s.section = sectp;
2670 this->gdb_index.size = bfd_get_section_size (sectp);
2672 else if (section_is_p (sectp->name, &names.debug_names))
2674 this->debug_names.s.section = sectp;
2675 this->debug_names.size = bfd_get_section_size (sectp);
2677 else if (section_is_p (sectp->name, &names.debug_aranges))
2679 this->debug_aranges.s.section = sectp;
2680 this->debug_aranges.size = bfd_get_section_size (sectp);
2683 if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2684 && bfd_section_vma (abfd, sectp) == 0)
2685 this->has_section_at_zero = true;
2688 /* A helper function that decides whether a section is empty,
2692 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2694 if (section->is_virtual)
2695 return section->size == 0;
2696 return section->s.section == NULL || section->size == 0;
2699 /* Read the contents of the section INFO.
2700 OBJFILE is the main object file, but not necessarily the file where
2701 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2703 If the section is compressed, uncompress it before returning. */
2706 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
2710 gdb_byte *buf, *retbuf;
2714 info->buffer = NULL;
2717 if (dwarf2_section_empty_p (info))
2720 sectp = get_section_bfd_section (info);
2722 /* If this is a virtual section we need to read in the real one first. */
2723 if (info->is_virtual)
2725 struct dwarf2_section_info *containing_section =
2726 get_containing_section (info);
2728 gdb_assert (sectp != NULL);
2729 if ((sectp->flags & SEC_RELOC) != 0)
2731 error (_("Dwarf Error: DWP format V2 with relocations is not"
2732 " supported in section %s [in module %s]"),
2733 get_section_name (info), get_section_file_name (info));
2735 dwarf2_read_section (objfile, containing_section);
2736 /* Other code should have already caught virtual sections that don't
2738 gdb_assert (info->virtual_offset + info->size
2739 <= containing_section->size);
2740 /* If the real section is empty or there was a problem reading the
2741 section we shouldn't get here. */
2742 gdb_assert (containing_section->buffer != NULL);
2743 info->buffer = containing_section->buffer + info->virtual_offset;
2747 /* If the section has relocations, we must read it ourselves.
2748 Otherwise we attach it to the BFD. */
2749 if ((sectp->flags & SEC_RELOC) == 0)
2751 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2755 buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2758 /* When debugging .o files, we may need to apply relocations; see
2759 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2760 We never compress sections in .o files, so we only need to
2761 try this when the section is not compressed. */
2762 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2765 info->buffer = retbuf;
2769 abfd = get_section_bfd_owner (info);
2770 gdb_assert (abfd != NULL);
2772 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2773 || bfd_bread (buf, info->size, abfd) != info->size)
2775 error (_("Dwarf Error: Can't read DWARF data"
2776 " in section %s [in module %s]"),
2777 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2781 /* A helper function that returns the size of a section in a safe way.
2782 If you are positive that the section has been read before using the
2783 size, then it is safe to refer to the dwarf2_section_info object's
2784 "size" field directly. In other cases, you must call this
2785 function, because for compressed sections the size field is not set
2786 correctly until the section has been read. */
2788 static bfd_size_type
2789 dwarf2_section_size (struct objfile *objfile,
2790 struct dwarf2_section_info *info)
2793 dwarf2_read_section (objfile, info);
2797 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2801 dwarf2_get_section_info (struct objfile *objfile,
2802 enum dwarf2_section_enum sect,
2803 asection **sectp, const gdb_byte **bufp,
2804 bfd_size_type *sizep)
2806 struct dwarf2_per_objfile *data
2807 = (struct dwarf2_per_objfile *) objfile_data (objfile,
2808 dwarf2_objfile_data_key);
2809 struct dwarf2_section_info *info;
2811 /* We may see an objfile without any DWARF, in which case we just
2822 case DWARF2_DEBUG_FRAME:
2823 info = &data->frame;
2825 case DWARF2_EH_FRAME:
2826 info = &data->eh_frame;
2829 gdb_assert_not_reached ("unexpected section");
2832 dwarf2_read_section (objfile, info);
2834 *sectp = get_section_bfd_section (info);
2835 *bufp = info->buffer;
2836 *sizep = info->size;
2839 /* A helper function to find the sections for a .dwz file. */
2842 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2844 struct dwz_file *dwz_file = (struct dwz_file *) arg;
2846 /* Note that we only support the standard ELF names, because .dwz
2847 is ELF-only (at the time of writing). */
2848 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2850 dwz_file->abbrev.s.section = sectp;
2851 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2853 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2855 dwz_file->info.s.section = sectp;
2856 dwz_file->info.size = bfd_get_section_size (sectp);
2858 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2860 dwz_file->str.s.section = sectp;
2861 dwz_file->str.size = bfd_get_section_size (sectp);
2863 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2865 dwz_file->line.s.section = sectp;
2866 dwz_file->line.size = bfd_get_section_size (sectp);
2868 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2870 dwz_file->macro.s.section = sectp;
2871 dwz_file->macro.size = bfd_get_section_size (sectp);
2873 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2875 dwz_file->gdb_index.s.section = sectp;
2876 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2878 else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2880 dwz_file->debug_names.s.section = sectp;
2881 dwz_file->debug_names.size = bfd_get_section_size (sectp);
2885 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2886 there is no .gnu_debugaltlink section in the file. Error if there
2887 is such a section but the file cannot be found. */
2889 static struct dwz_file *
2890 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2892 const char *filename;
2893 struct dwz_file *result;
2894 bfd_size_type buildid_len_arg;
2898 if (dwarf2_per_objfile->dwz_file != NULL)
2899 return dwarf2_per_objfile->dwz_file;
2901 bfd_set_error (bfd_error_no_error);
2902 gdb::unique_xmalloc_ptr<char> data
2903 (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2904 &buildid_len_arg, &buildid));
2907 if (bfd_get_error () == bfd_error_no_error)
2909 error (_("could not read '.gnu_debugaltlink' section: %s"),
2910 bfd_errmsg (bfd_get_error ()));
2913 gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2915 buildid_len = (size_t) buildid_len_arg;
2917 filename = data.get ();
2919 std::string abs_storage;
2920 if (!IS_ABSOLUTE_PATH (filename))
2922 gdb::unique_xmalloc_ptr<char> abs
2923 = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2925 abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2926 filename = abs_storage.c_str ();
2929 /* First try the file name given in the section. If that doesn't
2930 work, try to use the build-id instead. */
2931 gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2932 if (dwz_bfd != NULL)
2934 if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2938 if (dwz_bfd == NULL)
2939 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2941 if (dwz_bfd == NULL)
2942 error (_("could not find '.gnu_debugaltlink' file for %s"),
2943 objfile_name (dwarf2_per_objfile->objfile));
2945 result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
2947 result->dwz_bfd = dwz_bfd.release ();
2949 bfd_map_over_sections (result->dwz_bfd, locate_dwz_sections, result);
2951 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, result->dwz_bfd);
2952 dwarf2_per_objfile->dwz_file = result;
2956 /* DWARF quick_symbols_functions support. */
2958 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2959 unique line tables, so we maintain a separate table of all .debug_line
2960 derived entries to support the sharing.
2961 All the quick functions need is the list of file names. We discard the
2962 line_header when we're done and don't need to record it here. */
2963 struct quick_file_names
2965 /* The data used to construct the hash key. */
2966 struct stmt_list_hash hash;
2968 /* The number of entries in file_names, real_names. */
2969 unsigned int num_file_names;
2971 /* The file names from the line table, after being run through
2973 const char **file_names;
2975 /* The file names from the line table after being run through
2976 gdb_realpath. These are computed lazily. */
2977 const char **real_names;
2980 /* When using the index (and thus not using psymtabs), each CU has an
2981 object of this type. This is used to hold information needed by
2982 the various "quick" methods. */
2983 struct dwarf2_per_cu_quick_data
2985 /* The file table. This can be NULL if there was no file table
2986 or it's currently not read in.
2987 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2988 struct quick_file_names *file_names;
2990 /* The corresponding symbol table. This is NULL if symbols for this
2991 CU have not yet been read. */
2992 struct compunit_symtab *compunit_symtab;
2994 /* A temporary mark bit used when iterating over all CUs in
2995 expand_symtabs_matching. */
2996 unsigned int mark : 1;
2998 /* True if we've tried to read the file table and found there isn't one.
2999 There will be no point in trying to read it again next time. */
3000 unsigned int no_file_data : 1;
3003 /* Utility hash function for a stmt_list_hash. */
3006 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
3010 if (stmt_list_hash->dwo_unit != NULL)
3011 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
3012 v += to_underlying (stmt_list_hash->line_sect_off);
3016 /* Utility equality function for a stmt_list_hash. */
3019 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
3020 const struct stmt_list_hash *rhs)
3022 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
3024 if (lhs->dwo_unit != NULL
3025 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
3028 return lhs->line_sect_off == rhs->line_sect_off;
3031 /* Hash function for a quick_file_names. */
3034 hash_file_name_entry (const void *e)
3036 const struct quick_file_names *file_data
3037 = (const struct quick_file_names *) e;
3039 return hash_stmt_list_entry (&file_data->hash);
3042 /* Equality function for a quick_file_names. */
3045 eq_file_name_entry (const void *a, const void *b)
3047 const struct quick_file_names *ea = (const struct quick_file_names *) a;
3048 const struct quick_file_names *eb = (const struct quick_file_names *) b;
3050 return eq_stmt_list_entry (&ea->hash, &eb->hash);
3053 /* Delete function for a quick_file_names. */
3056 delete_file_name_entry (void *e)
3058 struct quick_file_names *file_data = (struct quick_file_names *) e;
3061 for (i = 0; i < file_data->num_file_names; ++i)
3063 xfree ((void*) file_data->file_names[i]);
3064 if (file_data->real_names)
3065 xfree ((void*) file_data->real_names[i]);
3068 /* The space for the struct itself lives on objfile_obstack,
3069 so we don't free it here. */
3072 /* Create a quick_file_names hash table. */
3075 create_quick_file_names_table (unsigned int nr_initial_entries)
3077 return htab_create_alloc (nr_initial_entries,
3078 hash_file_name_entry, eq_file_name_entry,
3079 delete_file_name_entry, xcalloc, xfree);
3082 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
3083 have to be created afterwards. You should call age_cached_comp_units after
3084 processing PER_CU->CU. dw2_setup must have been already called. */
3087 load_cu (struct dwarf2_per_cu_data *per_cu)
3089 if (per_cu->is_debug_types)
3090 load_full_type_unit (per_cu);
3092 load_full_comp_unit (per_cu, language_minimal);
3094 if (per_cu->cu == NULL)
3095 return; /* Dummy CU. */
3097 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
3100 /* Read in the symbols for PER_CU. */
3103 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
3105 struct cleanup *back_to;
3106 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
3108 /* Skip type_unit_groups, reading the type units they contain
3109 is handled elsewhere. */
3110 if (IS_TYPE_UNIT_GROUP (per_cu))
3113 back_to = make_cleanup (dwarf2_release_queue, NULL);
3115 if (dwarf2_per_objfile->using_index
3116 ? per_cu->v.quick->compunit_symtab == NULL
3117 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
3119 queue_comp_unit (per_cu, language_minimal);
3122 /* If we just loaded a CU from a DWO, and we're working with an index
3123 that may badly handle TUs, load all the TUs in that DWO as well.
3124 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
3125 if (!per_cu->is_debug_types
3126 && per_cu->cu != NULL
3127 && per_cu->cu->dwo_unit != NULL
3128 && dwarf2_per_objfile->index_table != NULL
3129 && dwarf2_per_objfile->index_table->version <= 7
3130 /* DWP files aren't supported yet. */
3131 && get_dwp_file (dwarf2_per_objfile) == NULL)
3132 queue_and_load_all_dwo_tus (per_cu);
3135 process_queue (dwarf2_per_objfile);
3137 /* Age the cache, releasing compilation units that have not
3138 been used recently. */
3139 age_cached_comp_units (dwarf2_per_objfile);
3141 do_cleanups (back_to);
3144 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
3145 the objfile from which this CU came. Returns the resulting symbol
3148 static struct compunit_symtab *
3149 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
3151 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
3153 gdb_assert (dwarf2_per_objfile->using_index);
3154 if (!per_cu->v.quick->compunit_symtab)
3156 struct cleanup *back_to = make_cleanup (free_cached_comp_units,
3157 dwarf2_per_objfile);
3158 scoped_restore decrementer = increment_reading_symtab ();
3159 dw2_do_instantiate_symtab (per_cu);
3160 process_cu_includes (dwarf2_per_objfile);
3161 do_cleanups (back_to);
3164 return per_cu->v.quick->compunit_symtab;
3167 /* Return the CU/TU given its index.
3169 This is intended for loops like:
3171 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3172 + dwarf2_per_objfile->n_type_units); ++i)
3174 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3180 static struct dwarf2_per_cu_data *
3181 dw2_get_cutu (struct dwarf2_per_objfile *dwarf2_per_objfile,
3184 if (index >= dwarf2_per_objfile->n_comp_units)
3186 index -= dwarf2_per_objfile->n_comp_units;
3187 gdb_assert (index < dwarf2_per_objfile->n_type_units);
3188 return &dwarf2_per_objfile->all_type_units[index]->per_cu;
3191 return dwarf2_per_objfile->all_comp_units[index];
3194 /* Return the CU given its index.
3195 This differs from dw2_get_cutu in that it's for when you know INDEX
3198 static struct dwarf2_per_cu_data *
3199 dw2_get_cu (struct dwarf2_per_objfile *dwarf2_per_objfile, int index)
3201 gdb_assert (index >= 0 && index < dwarf2_per_objfile->n_comp_units);
3203 return dwarf2_per_objfile->all_comp_units[index];
3206 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
3207 objfile_obstack, and constructed with the specified field
3210 static dwarf2_per_cu_data *
3211 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
3212 struct dwarf2_section_info *section,
3214 sect_offset sect_off, ULONGEST length)
3216 struct objfile *objfile = dwarf2_per_objfile->objfile;
3217 dwarf2_per_cu_data *the_cu
3218 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3219 struct dwarf2_per_cu_data);
3220 the_cu->sect_off = sect_off;
3221 the_cu->length = length;
3222 the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
3223 the_cu->section = section;
3224 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3225 struct dwarf2_per_cu_quick_data);
3226 the_cu->is_dwz = is_dwz;
3230 /* A helper for create_cus_from_index that handles a given list of
3234 create_cus_from_index_list (struct objfile *objfile,
3235 const gdb_byte *cu_list, offset_type n_elements,
3236 struct dwarf2_section_info *section,
3241 struct dwarf2_per_objfile *dwarf2_per_objfile
3242 = get_dwarf2_per_objfile (objfile);
3244 for (i = 0; i < n_elements; i += 2)
3246 gdb_static_assert (sizeof (ULONGEST) >= 8);
3248 sect_offset sect_off
3249 = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
3250 ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
3253 dwarf2_per_objfile->all_comp_units[base_offset + i / 2]
3254 = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
3259 /* Read the CU list from the mapped index, and use it to create all
3260 the CU objects for this objfile. */
3263 create_cus_from_index (struct objfile *objfile,
3264 const gdb_byte *cu_list, offset_type cu_list_elements,
3265 const gdb_byte *dwz_list, offset_type dwz_elements)
3267 struct dwz_file *dwz;
3268 struct dwarf2_per_objfile *dwarf2_per_objfile
3269 = get_dwarf2_per_objfile (objfile);
3271 dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
3272 dwarf2_per_objfile->all_comp_units =
3273 XOBNEWVEC (&objfile->objfile_obstack, struct dwarf2_per_cu_data *,
3274 dwarf2_per_objfile->n_comp_units);
3276 create_cus_from_index_list (objfile, cu_list, cu_list_elements,
3277 &dwarf2_per_objfile->info, 0, 0);
3279 if (dwz_elements == 0)
3282 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3283 create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
3284 cu_list_elements / 2);
3287 /* Create the signatured type hash table from the index. */
3290 create_signatured_type_table_from_index (struct objfile *objfile,
3291 struct dwarf2_section_info *section,
3292 const gdb_byte *bytes,
3293 offset_type elements)
3296 htab_t sig_types_hash;
3297 struct dwarf2_per_objfile *dwarf2_per_objfile
3298 = get_dwarf2_per_objfile (objfile);
3300 dwarf2_per_objfile->n_type_units
3301 = dwarf2_per_objfile->n_allocated_type_units
3303 dwarf2_per_objfile->all_type_units =
3304 XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
3306 sig_types_hash = allocate_signatured_type_table (objfile);
3308 for (i = 0; i < elements; i += 3)
3310 struct signatured_type *sig_type;
3313 cu_offset type_offset_in_tu;
3315 gdb_static_assert (sizeof (ULONGEST) >= 8);
3316 sect_offset sect_off
3317 = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3319 = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3321 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3324 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3325 struct signatured_type);
3326 sig_type->signature = signature;
3327 sig_type->type_offset_in_tu = type_offset_in_tu;
3328 sig_type->per_cu.is_debug_types = 1;
3329 sig_type->per_cu.section = section;
3330 sig_type->per_cu.sect_off = sect_off;
3331 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3332 sig_type->per_cu.v.quick
3333 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3334 struct dwarf2_per_cu_quick_data);
3336 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3339 dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
3342 dwarf2_per_objfile->signatured_types = sig_types_hash;
3345 /* Create the signatured type hash table from .debug_names. */
3348 create_signatured_type_table_from_debug_names
3349 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3350 const mapped_debug_names &map,
3351 struct dwarf2_section_info *section,
3352 struct dwarf2_section_info *abbrev_section)
3354 struct objfile *objfile = dwarf2_per_objfile->objfile;
3356 dwarf2_read_section (objfile, section);
3357 dwarf2_read_section (objfile, abbrev_section);
3359 dwarf2_per_objfile->n_type_units
3360 = dwarf2_per_objfile->n_allocated_type_units
3362 dwarf2_per_objfile->all_type_units
3363 = XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
3365 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3367 for (uint32_t i = 0; i < map.tu_count; ++i)
3369 struct signatured_type *sig_type;
3372 cu_offset type_offset_in_tu;
3374 sect_offset sect_off
3375 = (sect_offset) (extract_unsigned_integer
3376 (map.tu_table_reordered + i * map.offset_size,
3378 map.dwarf5_byte_order));
3380 comp_unit_head cu_header;
3381 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3383 section->buffer + to_underlying (sect_off),
3386 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3387 struct signatured_type);
3388 sig_type->signature = cu_header.signature;
3389 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3390 sig_type->per_cu.is_debug_types = 1;
3391 sig_type->per_cu.section = section;
3392 sig_type->per_cu.sect_off = sect_off;
3393 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3394 sig_type->per_cu.v.quick
3395 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3396 struct dwarf2_per_cu_quick_data);
3398 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3401 dwarf2_per_objfile->all_type_units[i] = sig_type;
3404 dwarf2_per_objfile->signatured_types = sig_types_hash;
3407 /* Read the address map data from the mapped index, and use it to
3408 populate the objfile's psymtabs_addrmap. */
3411 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3412 struct mapped_index *index)
3414 struct objfile *objfile = dwarf2_per_objfile->objfile;
3415 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3416 const gdb_byte *iter, *end;
3417 struct addrmap *mutable_map;
3420 auto_obstack temp_obstack;
3422 mutable_map = addrmap_create_mutable (&temp_obstack);
3424 iter = index->address_table.data ();
3425 end = iter + index->address_table.size ();
3427 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3431 ULONGEST hi, lo, cu_index;
3432 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3434 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3436 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3441 complaint (&symfile_complaints,
3442 _(".gdb_index address table has invalid range (%s - %s)"),
3443 hex_string (lo), hex_string (hi));
3447 if (cu_index >= dwarf2_per_objfile->n_comp_units)
3449 complaint (&symfile_complaints,
3450 _(".gdb_index address table has invalid CU number %u"),
3451 (unsigned) cu_index);
3455 lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr);
3456 hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr);
3457 addrmap_set_empty (mutable_map, lo, hi - 1,
3458 dw2_get_cutu (dwarf2_per_objfile, cu_index));
3461 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3462 &objfile->objfile_obstack);
3465 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3466 populate the objfile's psymtabs_addrmap. */
3469 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3470 struct dwarf2_section_info *section)
3472 struct objfile *objfile = dwarf2_per_objfile->objfile;
3473 bfd *abfd = objfile->obfd;
3474 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3475 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3476 SECT_OFF_TEXT (objfile));
3478 auto_obstack temp_obstack;
3479 addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3481 std::unordered_map<sect_offset,
3482 dwarf2_per_cu_data *,
3483 gdb::hash_enum<sect_offset>>
3484 debug_info_offset_to_per_cu;
3485 for (int cui = 0; cui < dwarf2_per_objfile->n_comp_units; ++cui)
3487 dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, cui);
3488 const auto insertpair
3489 = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3490 if (!insertpair.second)
3492 warning (_("Section .debug_aranges in %s has duplicate "
3493 "debug_info_offset %u, ignoring .debug_aranges."),
3494 objfile_name (objfile), to_underlying (per_cu->sect_off));
3499 dwarf2_read_section (objfile, section);
3501 const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3503 const gdb_byte *addr = section->buffer;
3505 while (addr < section->buffer + section->size)
3507 const gdb_byte *const entry_addr = addr;
3508 unsigned int bytes_read;
3510 const LONGEST entry_length = read_initial_length (abfd, addr,
3514 const gdb_byte *const entry_end = addr + entry_length;
3515 const bool dwarf5_is_dwarf64 = bytes_read != 4;
3516 const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3517 if (addr + entry_length > section->buffer + section->size)
3519 warning (_("Section .debug_aranges in %s entry at offset %zu "
3520 "length %s exceeds section length %s, "
3521 "ignoring .debug_aranges."),
3522 objfile_name (objfile), entry_addr - section->buffer,
3523 plongest (bytes_read + entry_length),
3524 pulongest (section->size));
3528 /* The version number. */
3529 const uint16_t version = read_2_bytes (abfd, addr);
3533 warning (_("Section .debug_aranges in %s entry at offset %zu "
3534 "has unsupported version %d, ignoring .debug_aranges."),
3535 objfile_name (objfile), entry_addr - section->buffer,
3540 const uint64_t debug_info_offset
3541 = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3542 addr += offset_size;
3543 const auto per_cu_it
3544 = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3545 if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3547 warning (_("Section .debug_aranges in %s entry at offset %zu "
3548 "debug_info_offset %s does not exists, "
3549 "ignoring .debug_aranges."),
3550 objfile_name (objfile), entry_addr - section->buffer,
3551 pulongest (debug_info_offset));
3554 dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3556 const uint8_t address_size = *addr++;
3557 if (address_size < 1 || address_size > 8)
3559 warning (_("Section .debug_aranges in %s entry at offset %zu "
3560 "address_size %u is invalid, ignoring .debug_aranges."),
3561 objfile_name (objfile), entry_addr - section->buffer,
3566 const uint8_t segment_selector_size = *addr++;
3567 if (segment_selector_size != 0)
3569 warning (_("Section .debug_aranges in %s entry at offset %zu "
3570 "segment_selector_size %u is not supported, "
3571 "ignoring .debug_aranges."),
3572 objfile_name (objfile), entry_addr - section->buffer,
3573 segment_selector_size);
3577 /* Must pad to an alignment boundary that is twice the address
3578 size. It is undocumented by the DWARF standard but GCC does
3580 for (size_t padding = ((-(addr - section->buffer))
3581 & (2 * address_size - 1));
3582 padding > 0; padding--)
3585 warning (_("Section .debug_aranges in %s entry at offset %zu "
3586 "padding is not zero, ignoring .debug_aranges."),
3587 objfile_name (objfile), entry_addr - section->buffer);
3593 if (addr + 2 * address_size > entry_end)
3595 warning (_("Section .debug_aranges in %s entry at offset %zu "
3596 "address list is not properly terminated, "
3597 "ignoring .debug_aranges."),
3598 objfile_name (objfile), entry_addr - section->buffer);
3601 ULONGEST start = extract_unsigned_integer (addr, address_size,
3603 addr += address_size;
3604 ULONGEST length = extract_unsigned_integer (addr, address_size,
3606 addr += address_size;
3607 if (start == 0 && length == 0)
3609 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3611 /* Symbol was eliminated due to a COMDAT group. */
3614 ULONGEST end = start + length;
3615 start = gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr);
3616 end = gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr);
3617 addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3621 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3622 &objfile->objfile_obstack);
3625 /* The hash function for strings in the mapped index. This is the same as
3626 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
3627 implementation. This is necessary because the hash function is tied to the
3628 format of the mapped index file. The hash values do not have to match with
3631 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
3634 mapped_index_string_hash (int index_version, const void *p)
3636 const unsigned char *str = (const unsigned char *) p;
3640 while ((c = *str++) != 0)
3642 if (index_version >= 5)
3644 r = r * 67 + c - 113;
3650 /* Find a slot in the mapped index INDEX for the object named NAME.
3651 If NAME is found, set *VEC_OUT to point to the CU vector in the
3652 constant pool and return true. If NAME cannot be found, return
3656 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3657 offset_type **vec_out)
3660 offset_type slot, step;
3661 int (*cmp) (const char *, const char *);
3663 gdb::unique_xmalloc_ptr<char> without_params;
3664 if (current_language->la_language == language_cplus
3665 || current_language->la_language == language_fortran
3666 || current_language->la_language == language_d)
3668 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3671 if (strchr (name, '(') != NULL)
3673 without_params = cp_remove_params (name);
3675 if (without_params != NULL)
3676 name = without_params.get ();
3680 /* Index version 4 did not support case insensitive searches. But the
3681 indices for case insensitive languages are built in lowercase, therefore
3682 simulate our NAME being searched is also lowercased. */
3683 hash = mapped_index_string_hash ((index->version == 4
3684 && case_sensitivity == case_sensitive_off
3685 ? 5 : index->version),
3688 slot = hash & (index->symbol_table.size () - 1);
3689 step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3690 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3696 const auto &bucket = index->symbol_table[slot];
3697 if (bucket.name == 0 && bucket.vec == 0)
3700 str = index->constant_pool + MAYBE_SWAP (bucket.name);
3701 if (!cmp (name, str))
3703 *vec_out = (offset_type *) (index->constant_pool
3704 + MAYBE_SWAP (bucket.vec));
3708 slot = (slot + step) & (index->symbol_table.size () - 1);
3712 /* A helper function that reads the .gdb_index from SECTION and fills
3713 in MAP. FILENAME is the name of the file containing the section;
3714 it is used for error reporting. DEPRECATED_OK is nonzero if it is
3715 ok to use deprecated sections.
3717 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3718 out parameters that are filled in with information about the CU and
3719 TU lists in the section.
3721 Returns 1 if all went well, 0 otherwise. */
3724 read_index_from_section (struct objfile *objfile,
3725 const char *filename,
3727 struct dwarf2_section_info *section,
3728 struct mapped_index *map,
3729 const gdb_byte **cu_list,
3730 offset_type *cu_list_elements,
3731 const gdb_byte **types_list,
3732 offset_type *types_list_elements)
3734 const gdb_byte *addr;
3735 offset_type version;
3736 offset_type *metadata;
3739 if (dwarf2_section_empty_p (section))
3742 /* Older elfutils strip versions could keep the section in the main
3743 executable while splitting it for the separate debug info file. */
3744 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
3747 dwarf2_read_section (objfile, section);
3749 addr = section->buffer;
3750 /* Version check. */
3751 version = MAYBE_SWAP (*(offset_type *) addr);
3752 /* Versions earlier than 3 emitted every copy of a psymbol. This
3753 causes the index to behave very poorly for certain requests. Version 3
3754 contained incomplete addrmap. So, it seems better to just ignore such
3758 static int warning_printed = 0;
3759 if (!warning_printed)
3761 warning (_("Skipping obsolete .gdb_index section in %s."),
3763 warning_printed = 1;
3767 /* Index version 4 uses a different hash function than index version
3770 Versions earlier than 6 did not emit psymbols for inlined
3771 functions. Using these files will cause GDB not to be able to
3772 set breakpoints on inlined functions by name, so we ignore these
3773 indices unless the user has done
3774 "set use-deprecated-index-sections on". */
3775 if (version < 6 && !deprecated_ok)
3777 static int warning_printed = 0;
3778 if (!warning_printed)
3781 Skipping deprecated .gdb_index section in %s.\n\
3782 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3783 to use the section anyway."),
3785 warning_printed = 1;
3789 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3790 of the TU (for symbols coming from TUs),
3791 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3792 Plus gold-generated indices can have duplicate entries for global symbols,
3793 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3794 These are just performance bugs, and we can't distinguish gdb-generated
3795 indices from gold-generated ones, so issue no warning here. */
3797 /* Indexes with higher version than the one supported by GDB may be no
3798 longer backward compatible. */
3802 map->version = version;
3803 map->total_size = section->size;
3805 metadata = (offset_type *) (addr + sizeof (offset_type));
3808 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3809 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3813 *types_list = addr + MAYBE_SWAP (metadata[i]);
3814 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3815 - MAYBE_SWAP (metadata[i]))
3819 const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3820 const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3822 = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3825 const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3826 const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3828 = gdb::array_view<mapped_index::symbol_table_slot>
3829 ((mapped_index::symbol_table_slot *) symbol_table,
3830 (mapped_index::symbol_table_slot *) symbol_table_end);
3833 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3838 /* Read .gdb_index. If everything went ok, initialize the "quick"
3839 elements of all the CUs and return 1. Otherwise, return 0. */
3842 dwarf2_read_index (struct objfile *objfile)
3844 struct mapped_index local_map, *map;
3845 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3846 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3847 struct dwz_file *dwz;
3848 struct dwarf2_per_objfile *dwarf2_per_objfile
3849 = get_dwarf2_per_objfile (objfile);
3851 if (!read_index_from_section (objfile, objfile_name (objfile),
3852 use_deprecated_index_sections,
3853 &dwarf2_per_objfile->gdb_index, &local_map,
3854 &cu_list, &cu_list_elements,
3855 &types_list, &types_list_elements))
3858 /* Don't use the index if it's empty. */
3859 if (local_map.symbol_table.empty ())
3862 /* If there is a .dwz file, read it so we can get its CU list as
3864 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3867 struct mapped_index dwz_map;
3868 const gdb_byte *dwz_types_ignore;
3869 offset_type dwz_types_elements_ignore;
3871 if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
3873 &dwz->gdb_index, &dwz_map,
3874 &dwz_list, &dwz_list_elements,
3876 &dwz_types_elements_ignore))
3878 warning (_("could not read '.gdb_index' section from %s; skipping"),
3879 bfd_get_filename (dwz->dwz_bfd));
3884 create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
3887 if (types_list_elements)
3889 struct dwarf2_section_info *section;
3891 /* We can only handle a single .debug_types when we have an
3893 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3896 section = VEC_index (dwarf2_section_info_def,
3897 dwarf2_per_objfile->types, 0);
3899 create_signatured_type_table_from_index (objfile, section, types_list,
3900 types_list_elements);
3903 create_addrmap_from_index (dwarf2_per_objfile, &local_map);
3905 map = XOBNEW (&objfile->objfile_obstack, struct mapped_index);
3906 map = new (map) mapped_index ();
3909 dwarf2_per_objfile->index_table = map;
3910 dwarf2_per_objfile->using_index = 1;
3911 dwarf2_per_objfile->quick_file_names_table =
3912 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
3917 /* die_reader_func for dw2_get_file_names. */
3920 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3921 const gdb_byte *info_ptr,
3922 struct die_info *comp_unit_die,
3926 struct dwarf2_cu *cu = reader->cu;
3927 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3928 struct dwarf2_per_objfile *dwarf2_per_objfile
3929 = cu->per_cu->dwarf2_per_objfile;
3930 struct objfile *objfile = dwarf2_per_objfile->objfile;
3931 struct dwarf2_per_cu_data *lh_cu;
3932 struct attribute *attr;
3935 struct quick_file_names *qfn;
3937 gdb_assert (! this_cu->is_debug_types);
3939 /* Our callers never want to match partial units -- instead they
3940 will match the enclosing full CU. */
3941 if (comp_unit_die->tag == DW_TAG_partial_unit)
3943 this_cu->v.quick->no_file_data = 1;
3951 sect_offset line_offset {};
3953 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3956 struct quick_file_names find_entry;
3958 line_offset = (sect_offset) DW_UNSND (attr);
3960 /* We may have already read in this line header (TU line header sharing).
3961 If we have we're done. */
3962 find_entry.hash.dwo_unit = cu->dwo_unit;
3963 find_entry.hash.line_sect_off = line_offset;
3964 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3965 &find_entry, INSERT);
3968 lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3972 lh = dwarf_decode_line_header (line_offset, cu);
3976 lh_cu->v.quick->no_file_data = 1;
3980 qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3981 qfn->hash.dwo_unit = cu->dwo_unit;
3982 qfn->hash.line_sect_off = line_offset;
3983 gdb_assert (slot != NULL);
3986 file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3988 qfn->num_file_names = lh->file_names.size ();
3990 XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3991 for (i = 0; i < lh->file_names.size (); ++i)
3992 qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3993 qfn->real_names = NULL;
3995 lh_cu->v.quick->file_names = qfn;
3998 /* A helper for the "quick" functions which attempts to read the line
3999 table for THIS_CU. */
4001 static struct quick_file_names *
4002 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
4004 /* This should never be called for TUs. */
4005 gdb_assert (! this_cu->is_debug_types);
4006 /* Nor type unit groups. */
4007 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
4009 if (this_cu->v.quick->file_names != NULL)
4010 return this_cu->v.quick->file_names;
4011 /* If we know there is no line data, no point in looking again. */
4012 if (this_cu->v.quick->no_file_data)
4015 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
4017 if (this_cu->v.quick->no_file_data)
4019 return this_cu->v.quick->file_names;
4022 /* A helper for the "quick" functions which computes and caches the
4023 real path for a given file name from the line table. */
4026 dw2_get_real_path (struct objfile *objfile,
4027 struct quick_file_names *qfn, int index)
4029 if (qfn->real_names == NULL)
4030 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
4031 qfn->num_file_names, const char *);
4033 if (qfn->real_names[index] == NULL)
4034 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
4036 return qfn->real_names[index];
4039 static struct symtab *
4040 dw2_find_last_source_symtab (struct objfile *objfile)
4042 struct dwarf2_per_objfile *dwarf2_per_objfile
4043 = get_dwarf2_per_objfile (objfile);
4044 int index = dwarf2_per_objfile->n_comp_units - 1;
4045 dwarf2_per_cu_data *dwarf_cu = dw2_get_cutu (dwarf2_per_objfile, index);
4046 compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu);
4051 return compunit_primary_filetab (cust);
4054 /* Traversal function for dw2_forget_cached_source_info. */
4057 dw2_free_cached_file_names (void **slot, void *info)
4059 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
4061 if (file_data->real_names)
4065 for (i = 0; i < file_data->num_file_names; ++i)
4067 xfree ((void*) file_data->real_names[i]);
4068 file_data->real_names[i] = NULL;
4076 dw2_forget_cached_source_info (struct objfile *objfile)
4078 struct dwarf2_per_objfile *dwarf2_per_objfile
4079 = get_dwarf2_per_objfile (objfile);
4081 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
4082 dw2_free_cached_file_names, NULL);
4085 /* Helper function for dw2_map_symtabs_matching_filename that expands
4086 the symtabs and calls the iterator. */
4089 dw2_map_expand_apply (struct objfile *objfile,
4090 struct dwarf2_per_cu_data *per_cu,
4091 const char *name, const char *real_path,
4092 gdb::function_view<bool (symtab *)> callback)
4094 struct compunit_symtab *last_made = objfile->compunit_symtabs;
4096 /* Don't visit already-expanded CUs. */
4097 if (per_cu->v.quick->compunit_symtab)
4100 /* This may expand more than one symtab, and we want to iterate over
4102 dw2_instantiate_symtab (per_cu);
4104 return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
4105 last_made, callback);
4108 /* Implementation of the map_symtabs_matching_filename method. */
4111 dw2_map_symtabs_matching_filename
4112 (struct objfile *objfile, const char *name, const char *real_path,
4113 gdb::function_view<bool (symtab *)> callback)
4116 const char *name_basename = lbasename (name);
4117 struct dwarf2_per_objfile *dwarf2_per_objfile
4118 = get_dwarf2_per_objfile (objfile);
4120 /* The rule is CUs specify all the files, including those used by
4121 any TU, so there's no need to scan TUs here. */
4123 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4126 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (dwarf2_per_objfile, i);
4127 struct quick_file_names *file_data;
4129 /* We only need to look at symtabs not already expanded. */
4130 if (per_cu->v.quick->compunit_symtab)
4133 file_data = dw2_get_file_names (per_cu);
4134 if (file_data == NULL)
4137 for (j = 0; j < file_data->num_file_names; ++j)
4139 const char *this_name = file_data->file_names[j];
4140 const char *this_real_name;
4142 if (compare_filenames_for_search (this_name, name))
4144 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
4150 /* Before we invoke realpath, which can get expensive when many
4151 files are involved, do a quick comparison of the basenames. */
4152 if (! basenames_may_differ
4153 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
4156 this_real_name = dw2_get_real_path (objfile, file_data, j);
4157 if (compare_filenames_for_search (this_real_name, name))
4159 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
4165 if (real_path != NULL)
4167 gdb_assert (IS_ABSOLUTE_PATH (real_path));
4168 gdb_assert (IS_ABSOLUTE_PATH (name));
4169 if (this_real_name != NULL
4170 && FILENAME_CMP (real_path, this_real_name) == 0)
4172 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
4184 /* Struct used to manage iterating over all CUs looking for a symbol. */
4186 struct dw2_symtab_iterator
4188 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
4189 struct dwarf2_per_objfile *dwarf2_per_objfile;
4190 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
4191 int want_specific_block;
4192 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
4193 Unused if !WANT_SPECIFIC_BLOCK. */
4195 /* The kind of symbol we're looking for. */
4197 /* The list of CUs from the index entry of the symbol,
4198 or NULL if not found. */
4200 /* The next element in VEC to look at. */
4202 /* The number of elements in VEC, or zero if there is no match. */
4204 /* Have we seen a global version of the symbol?
4205 If so we can ignore all further global instances.
4206 This is to work around gold/15646, inefficient gold-generated
4211 /* Initialize the index symtab iterator ITER.
4212 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
4213 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
4216 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
4217 struct dwarf2_per_objfile *dwarf2_per_objfile,
4218 int want_specific_block,
4223 iter->dwarf2_per_objfile = dwarf2_per_objfile;
4224 iter->want_specific_block = want_specific_block;
4225 iter->block_index = block_index;
4226 iter->domain = domain;
4228 iter->global_seen = 0;
4230 mapped_index *index = dwarf2_per_objfile->index_table;
4232 /* index is NULL if OBJF_READNOW. */
4233 if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
4234 iter->length = MAYBE_SWAP (*iter->vec);
4242 /* Return the next matching CU or NULL if there are no more. */
4244 static struct dwarf2_per_cu_data *
4245 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
4247 struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
4249 for ( ; iter->next < iter->length; ++iter->next)
4251 offset_type cu_index_and_attrs =
4252 MAYBE_SWAP (iter->vec[iter->next + 1]);
4253 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
4254 struct dwarf2_per_cu_data *per_cu;
4255 int want_static = iter->block_index != GLOBAL_BLOCK;
4256 /* This value is only valid for index versions >= 7. */
4257 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
4258 gdb_index_symbol_kind symbol_kind =
4259 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
4260 /* Only check the symbol attributes if they're present.
4261 Indices prior to version 7 don't record them,
4262 and indices >= 7 may elide them for certain symbols
4263 (gold does this). */
4265 (dwarf2_per_objfile->index_table->version >= 7
4266 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
4268 /* Don't crash on bad data. */
4269 if (cu_index >= (dwarf2_per_objfile->n_comp_units
4270 + dwarf2_per_objfile->n_type_units))
4272 complaint (&symfile_complaints,
4273 _(".gdb_index entry has bad CU index"
4275 objfile_name (dwarf2_per_objfile->objfile));
4279 per_cu = dw2_get_cutu (dwarf2_per_objfile, cu_index);
4281 /* Skip if already read in. */
4282 if (per_cu->v.quick->compunit_symtab)
4285 /* Check static vs global. */
4288 if (iter->want_specific_block
4289 && want_static != is_static)
4291 /* Work around gold/15646. */
4292 if (!is_static && iter->global_seen)
4295 iter->global_seen = 1;
4298 /* Only check the symbol's kind if it has one. */
4301 switch (iter->domain)
4304 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
4305 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
4306 /* Some types are also in VAR_DOMAIN. */
4307 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4311 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4315 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4330 static struct compunit_symtab *
4331 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4332 const char *name, domain_enum domain)
4334 struct compunit_symtab *stab_best = NULL;
4335 struct dwarf2_per_objfile *dwarf2_per_objfile
4336 = get_dwarf2_per_objfile (objfile);
4338 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4340 struct dw2_symtab_iterator iter;
4341 struct dwarf2_per_cu_data *per_cu;
4343 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4345 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4347 struct symbol *sym, *with_opaque = NULL;
4348 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu);
4349 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4350 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4352 sym = block_find_symbol (block, name, domain,
4353 block_find_non_opaque_type_preferred,
4356 /* Some caution must be observed with overloaded functions
4357 and methods, since the index will not contain any overload
4358 information (but NAME might contain it). */
4361 && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4363 if (with_opaque != NULL
4364 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4367 /* Keep looking through other CUs. */
4374 dw2_print_stats (struct objfile *objfile)
4376 struct dwarf2_per_objfile *dwarf2_per_objfile
4377 = get_dwarf2_per_objfile (objfile);
4378 int total = dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units;
4381 for (int i = 0; i < total; ++i)
4383 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
4385 if (!per_cu->v.quick->compunit_symtab)
4388 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
4389 printf_filtered (_(" Number of unread CUs: %d\n"), count);
4392 /* This dumps minimal information about the index.
4393 It is called via "mt print objfiles".
4394 One use is to verify .gdb_index has been loaded by the
4395 gdb.dwarf2/gdb-index.exp testcase. */
4398 dw2_dump (struct objfile *objfile)
4400 struct dwarf2_per_objfile *dwarf2_per_objfile
4401 = get_dwarf2_per_objfile (objfile);
4403 gdb_assert (dwarf2_per_objfile->using_index);
4404 printf_filtered (".gdb_index:");
4405 if (dwarf2_per_objfile->index_table != NULL)
4407 printf_filtered (" version %d\n",
4408 dwarf2_per_objfile->index_table->version);
4411 printf_filtered (" faked for \"readnow\"\n");
4412 printf_filtered ("\n");
4416 dw2_relocate (struct objfile *objfile,
4417 const struct section_offsets *new_offsets,
4418 const struct section_offsets *delta)
4420 /* There's nothing to relocate here. */
4424 dw2_expand_symtabs_for_function (struct objfile *objfile,
4425 const char *func_name)
4427 struct dwarf2_per_objfile *dwarf2_per_objfile
4428 = get_dwarf2_per_objfile (objfile);
4430 struct dw2_symtab_iterator iter;
4431 struct dwarf2_per_cu_data *per_cu;
4433 /* Note: It doesn't matter what we pass for block_index here. */
4434 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4437 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4438 dw2_instantiate_symtab (per_cu);
4443 dw2_expand_all_symtabs (struct objfile *objfile)
4445 struct dwarf2_per_objfile *dwarf2_per_objfile
4446 = get_dwarf2_per_objfile (objfile);
4447 int total_units = (dwarf2_per_objfile->n_comp_units
4448 + dwarf2_per_objfile->n_type_units);
4450 for (int i = 0; i < total_units; ++i)
4452 struct dwarf2_per_cu_data *per_cu
4453 = dw2_get_cutu (dwarf2_per_objfile, i);
4455 dw2_instantiate_symtab (per_cu);
4460 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4461 const char *fullname)
4463 struct dwarf2_per_objfile *dwarf2_per_objfile
4464 = get_dwarf2_per_objfile (objfile);
4466 /* We don't need to consider type units here.
4467 This is only called for examining code, e.g. expand_line_sal.
4468 There can be an order of magnitude (or more) more type units
4469 than comp units, and we avoid them if we can. */
4471 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4474 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
4475 struct quick_file_names *file_data;
4477 /* We only need to look at symtabs not already expanded. */
4478 if (per_cu->v.quick->compunit_symtab)
4481 file_data = dw2_get_file_names (per_cu);
4482 if (file_data == NULL)
4485 for (j = 0; j < file_data->num_file_names; ++j)
4487 const char *this_fullname = file_data->file_names[j];
4489 if (filename_cmp (this_fullname, fullname) == 0)
4491 dw2_instantiate_symtab (per_cu);
4499 dw2_map_matching_symbols (struct objfile *objfile,
4500 const char * name, domain_enum domain,
4502 int (*callback) (struct block *,
4503 struct symbol *, void *),
4504 void *data, symbol_name_match_type match,
4505 symbol_compare_ftype *ordered_compare)
4507 /* Currently unimplemented; used for Ada. The function can be called if the
4508 current language is Ada for a non-Ada objfile using GNU index. As Ada
4509 does not look for non-Ada symbols this function should just return. */
4512 /* Symbol name matcher for .gdb_index names.
4514 Symbol names in .gdb_index have a few particularities:
4516 - There's no indication of which is the language of each symbol.
4518 Since each language has its own symbol name matching algorithm,
4519 and we don't know which language is the right one, we must match
4520 each symbol against all languages. This would be a potential
4521 performance problem if it were not mitigated by the
4522 mapped_index::name_components lookup table, which significantly
4523 reduces the number of times we need to call into this matcher,
4524 making it a non-issue.
4526 - Symbol names in the index have no overload (parameter)
4527 information. I.e., in C++, "foo(int)" and "foo(long)" both
4528 appear as "foo" in the index, for example.
4530 This means that the lookup names passed to the symbol name
4531 matcher functions must have no parameter information either
4532 because (e.g.) symbol search name "foo" does not match
4533 lookup-name "foo(int)" [while swapping search name for lookup
4536 class gdb_index_symbol_name_matcher
4539 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4540 gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4542 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4543 Returns true if any matcher matches. */
4544 bool matches (const char *symbol_name);
4547 /* A reference to the lookup name we're matching against. */
4548 const lookup_name_info &m_lookup_name;
4550 /* A vector holding all the different symbol name matchers, for all
4552 std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4555 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4556 (const lookup_name_info &lookup_name)
4557 : m_lookup_name (lookup_name)
4559 /* Prepare the vector of comparison functions upfront, to avoid
4560 doing the same work for each symbol. Care is taken to avoid
4561 matching with the same matcher more than once if/when multiple
4562 languages use the same matcher function. */
4563 auto &matchers = m_symbol_name_matcher_funcs;
4564 matchers.reserve (nr_languages);
4566 matchers.push_back (default_symbol_name_matcher);
4568 for (int i = 0; i < nr_languages; i++)
4570 const language_defn *lang = language_def ((enum language) i);
4571 symbol_name_matcher_ftype *name_matcher
4572 = get_symbol_name_matcher (lang, m_lookup_name);
4574 /* Don't insert the same comparison routine more than once.
4575 Note that we do this linear walk instead of a seemingly
4576 cheaper sorted insert, or use a std::set or something like
4577 that, because relative order of function addresses is not
4578 stable. This is not a problem in practice because the number
4579 of supported languages is low, and the cost here is tiny
4580 compared to the number of searches we'll do afterwards using
4582 if (name_matcher != default_symbol_name_matcher
4583 && (std::find (matchers.begin (), matchers.end (), name_matcher)
4584 == matchers.end ()))
4585 matchers.push_back (name_matcher);
4590 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4592 for (auto matches_name : m_symbol_name_matcher_funcs)
4593 if (matches_name (symbol_name, m_lookup_name, NULL))
4599 /* Starting from a search name, return the string that finds the upper
4600 bound of all strings that start with SEARCH_NAME in a sorted name
4601 list. Returns the empty string to indicate that the upper bound is
4602 the end of the list. */
4605 make_sort_after_prefix_name (const char *search_name)
4607 /* When looking to complete "func", we find the upper bound of all
4608 symbols that start with "func" by looking for where we'd insert
4609 the closest string that would follow "func" in lexicographical
4610 order. Usually, that's "func"-with-last-character-incremented,
4611 i.e. "fund". Mind non-ASCII characters, though. Usually those
4612 will be UTF-8 multi-byte sequences, but we can't be certain.
4613 Especially mind the 0xff character, which is a valid character in
4614 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4615 rule out compilers allowing it in identifiers. Note that
4616 conveniently, strcmp/strcasecmp are specified to compare
4617 characters interpreted as unsigned char. So what we do is treat
4618 the whole string as a base 256 number composed of a sequence of
4619 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4620 to 0, and carries 1 to the following more-significant position.
4621 If the very first character in SEARCH_NAME ends up incremented
4622 and carries/overflows, then the upper bound is the end of the
4623 list. The string after the empty string is also the empty
4626 Some examples of this operation:
4628 SEARCH_NAME => "+1" RESULT
4632 "\xff" "a" "\xff" => "\xff" "b"
4637 Then, with these symbols for example:
4643 completing "func" looks for symbols between "func" and
4644 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4645 which finds "func" and "func1", but not "fund".
4649 funcÿ (Latin1 'ÿ' [0xff])
4653 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4654 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4658 ÿÿ (Latin1 'ÿ' [0xff])
4661 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4662 the end of the list.
4664 std::string after = search_name;
4665 while (!after.empty () && (unsigned char) after.back () == 0xff)
4667 if (!after.empty ())
4668 after.back () = (unsigned char) after.back () + 1;
4672 /* See declaration. */
4674 std::pair<std::vector<name_component>::const_iterator,
4675 std::vector<name_component>::const_iterator>
4676 mapped_index_base::find_name_components_bounds
4677 (const lookup_name_info &lookup_name_without_params) const
4680 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4683 = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4685 /* Comparison function object for lower_bound that matches against a
4686 given symbol name. */
4687 auto lookup_compare_lower = [&] (const name_component &elem,
4690 const char *elem_qualified = this->symbol_name_at (elem.idx);
4691 const char *elem_name = elem_qualified + elem.name_offset;
4692 return name_cmp (elem_name, name) < 0;
4695 /* Comparison function object for upper_bound that matches against a
4696 given symbol name. */
4697 auto lookup_compare_upper = [&] (const char *name,
4698 const name_component &elem)
4700 const char *elem_qualified = this->symbol_name_at (elem.idx);
4701 const char *elem_name = elem_qualified + elem.name_offset;
4702 return name_cmp (name, elem_name) < 0;
4705 auto begin = this->name_components.begin ();
4706 auto end = this->name_components.end ();
4708 /* Find the lower bound. */
4711 if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4714 return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4717 /* Find the upper bound. */
4720 if (lookup_name_without_params.completion_mode ())
4722 /* In completion mode, we want UPPER to point past all
4723 symbols names that have the same prefix. I.e., with
4724 these symbols, and completing "func":
4726 function << lower bound
4728 other_function << upper bound
4730 We find the upper bound by looking for the insertion
4731 point of "func"-with-last-character-incremented,
4733 std::string after = make_sort_after_prefix_name (cplus);
4736 return std::lower_bound (lower, end, after.c_str (),
4737 lookup_compare_lower);
4740 return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4743 return {lower, upper};
4746 /* See declaration. */
4749 mapped_index_base::build_name_components ()
4751 if (!this->name_components.empty ())
4754 this->name_components_casing = case_sensitivity;
4756 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4758 /* The code below only knows how to break apart components of C++
4759 symbol names (and other languages that use '::' as
4760 namespace/module separator). If we add support for wild matching
4761 to some language that uses some other operator (E.g., Ada, Go and
4762 D use '.'), then we'll need to try splitting the symbol name
4763 according to that language too. Note that Ada does support wild
4764 matching, but doesn't currently support .gdb_index. */
4765 auto count = this->symbol_name_count ();
4766 for (offset_type idx = 0; idx < count; idx++)
4768 if (this->symbol_name_slot_invalid (idx))
4771 const char *name = this->symbol_name_at (idx);
4773 /* Add each name component to the name component table. */
4774 unsigned int previous_len = 0;
4775 for (unsigned int current_len = cp_find_first_component (name);
4776 name[current_len] != '\0';
4777 current_len += cp_find_first_component (name + current_len))
4779 gdb_assert (name[current_len] == ':');
4780 this->name_components.push_back ({previous_len, idx});
4781 /* Skip the '::'. */
4783 previous_len = current_len;
4785 this->name_components.push_back ({previous_len, idx});
4788 /* Sort name_components elements by name. */
4789 auto name_comp_compare = [&] (const name_component &left,
4790 const name_component &right)
4792 const char *left_qualified = this->symbol_name_at (left.idx);
4793 const char *right_qualified = this->symbol_name_at (right.idx);
4795 const char *left_name = left_qualified + left.name_offset;
4796 const char *right_name = right_qualified + right.name_offset;
4798 return name_cmp (left_name, right_name) < 0;
4801 std::sort (this->name_components.begin (),
4802 this->name_components.end (),
4806 /* Helper for dw2_expand_symtabs_matching that works with a
4807 mapped_index_base instead of the containing objfile. This is split
4808 to a separate function in order to be able to unit test the
4809 name_components matching using a mock mapped_index_base. For each
4810 symbol name that matches, calls MATCH_CALLBACK, passing it the
4811 symbol's index in the mapped_index_base symbol table. */
4814 dw2_expand_symtabs_matching_symbol
4815 (mapped_index_base &index,
4816 const lookup_name_info &lookup_name_in,
4817 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4818 enum search_domain kind,
4819 gdb::function_view<void (offset_type)> match_callback)
4821 lookup_name_info lookup_name_without_params
4822 = lookup_name_in.make_ignore_params ();
4823 gdb_index_symbol_name_matcher lookup_name_matcher
4824 (lookup_name_without_params);
4826 /* Build the symbol name component sorted vector, if we haven't
4828 index.build_name_components ();
4830 auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4832 /* Now for each symbol name in range, check to see if we have a name
4833 match, and if so, call the MATCH_CALLBACK callback. */
4835 /* The same symbol may appear more than once in the range though.
4836 E.g., if we're looking for symbols that complete "w", and we have
4837 a symbol named "w1::w2", we'll find the two name components for
4838 that same symbol in the range. To be sure we only call the
4839 callback once per symbol, we first collect the symbol name
4840 indexes that matched in a temporary vector and ignore
4842 std::vector<offset_type> matches;
4843 matches.reserve (std::distance (bounds.first, bounds.second));
4845 for (; bounds.first != bounds.second; ++bounds.first)
4847 const char *qualified = index.symbol_name_at (bounds.first->idx);
4849 if (!lookup_name_matcher.matches (qualified)
4850 || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4853 matches.push_back (bounds.first->idx);
4856 std::sort (matches.begin (), matches.end ());
4858 /* Finally call the callback, once per match. */
4860 for (offset_type idx : matches)
4864 match_callback (idx);
4869 /* Above we use a type wider than idx's for 'prev', since 0 and
4870 (offset_type)-1 are both possible values. */
4871 static_assert (sizeof (prev) > sizeof (offset_type), "");
4876 namespace selftests { namespace dw2_expand_symtabs_matching {
4878 /* A mock .gdb_index/.debug_names-like name index table, enough to
4879 exercise dw2_expand_symtabs_matching_symbol, which works with the
4880 mapped_index_base interface. Builds an index from the symbol list
4881 passed as parameter to the constructor. */
4882 class mock_mapped_index : public mapped_index_base
4885 mock_mapped_index (gdb::array_view<const char *> symbols)
4886 : m_symbol_table (symbols)
4889 DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4891 /* Return the number of names in the symbol table. */
4892 virtual size_t symbol_name_count () const
4894 return m_symbol_table.size ();
4897 /* Get the name of the symbol at IDX in the symbol table. */
4898 virtual const char *symbol_name_at (offset_type idx) const
4900 return m_symbol_table[idx];
4904 gdb::array_view<const char *> m_symbol_table;
4907 /* Convenience function that converts a NULL pointer to a "<null>"
4908 string, to pass to print routines. */
4911 string_or_null (const char *str)
4913 return str != NULL ? str : "<null>";
4916 /* Check if a lookup_name_info built from
4917 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4918 index. EXPECTED_LIST is the list of expected matches, in expected
4919 matching order. If no match expected, then an empty list is
4920 specified. Returns true on success. On failure prints a warning
4921 indicating the file:line that failed, and returns false. */
4924 check_match (const char *file, int line,
4925 mock_mapped_index &mock_index,
4926 const char *name, symbol_name_match_type match_type,
4927 bool completion_mode,
4928 std::initializer_list<const char *> expected_list)
4930 lookup_name_info lookup_name (name, match_type, completion_mode);
4932 bool matched = true;
4934 auto mismatch = [&] (const char *expected_str,
4937 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4938 "expected=\"%s\", got=\"%s\"\n"),
4940 (match_type == symbol_name_match_type::FULL
4942 name, string_or_null (expected_str), string_or_null (got));
4946 auto expected_it = expected_list.begin ();
4947 auto expected_end = expected_list.end ();
4949 dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4951 [&] (offset_type idx)
4953 const char *matched_name = mock_index.symbol_name_at (idx);
4954 const char *expected_str
4955 = expected_it == expected_end ? NULL : *expected_it++;
4957 if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4958 mismatch (expected_str, matched_name);
4961 const char *expected_str
4962 = expected_it == expected_end ? NULL : *expected_it++;
4963 if (expected_str != NULL)
4964 mismatch (expected_str, NULL);
4969 /* The symbols added to the mock mapped_index for testing (in
4971 static const char *test_symbols[] = {
4980 "ns2::tmpl<int>::foo2",
4981 "(anonymous namespace)::A::B::C",
4983 /* These are used to check that the increment-last-char in the
4984 matching algorithm for completion doesn't match "t1_fund" when
4985 completing "t1_func". */
4991 /* A UTF-8 name with multi-byte sequences to make sure that
4992 cp-name-parser understands this as a single identifier ("função"
4993 is "function" in PT). */
4996 /* \377 (0xff) is Latin1 'ÿ'. */
4999 /* \377 (0xff) is Latin1 'ÿ'. */
5003 /* A name with all sorts of complications. Starts with "z" to make
5004 it easier for the completion tests below. */
5005 #define Z_SYM_NAME \
5006 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
5007 "::tuple<(anonymous namespace)::ui*, " \
5008 "std::default_delete<(anonymous namespace)::ui>, void>"
5013 /* Returns true if the mapped_index_base::find_name_component_bounds
5014 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
5015 in completion mode. */
5018 check_find_bounds_finds (mapped_index_base &index,
5019 const char *search_name,
5020 gdb::array_view<const char *> expected_syms)
5022 lookup_name_info lookup_name (search_name,
5023 symbol_name_match_type::FULL, true);
5025 auto bounds = index.find_name_components_bounds (lookup_name);
5027 size_t distance = std::distance (bounds.first, bounds.second);
5028 if (distance != expected_syms.size ())
5031 for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
5033 auto nc_elem = bounds.first + exp_elem;
5034 const char *qualified = index.symbol_name_at (nc_elem->idx);
5035 if (strcmp (qualified, expected_syms[exp_elem]) != 0)
5042 /* Test the lower-level mapped_index::find_name_component_bounds
5046 test_mapped_index_find_name_component_bounds ()
5048 mock_mapped_index mock_index (test_symbols);
5050 mock_index.build_name_components ();
5052 /* Test the lower-level mapped_index::find_name_component_bounds
5053 method in completion mode. */
5055 static const char *expected_syms[] = {
5060 SELF_CHECK (check_find_bounds_finds (mock_index,
5061 "t1_func", expected_syms));
5064 /* Check that the increment-last-char in the name matching algorithm
5065 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
5067 static const char *expected_syms1[] = {
5071 SELF_CHECK (check_find_bounds_finds (mock_index,
5072 "\377", expected_syms1));
5074 static const char *expected_syms2[] = {
5077 SELF_CHECK (check_find_bounds_finds (mock_index,
5078 "\377\377", expected_syms2));
5082 /* Test dw2_expand_symtabs_matching_symbol. */
5085 test_dw2_expand_symtabs_matching_symbol ()
5087 mock_mapped_index mock_index (test_symbols);
5089 /* We let all tests run until the end even if some fails, for debug
5091 bool any_mismatch = false;
5093 /* Create the expected symbols list (an initializer_list). Needed
5094 because lists have commas, and we need to pass them to CHECK,
5095 which is a macro. */
5096 #define EXPECT(...) { __VA_ARGS__ }
5098 /* Wrapper for check_match that passes down the current
5099 __FILE__/__LINE__. */
5100 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
5101 any_mismatch |= !check_match (__FILE__, __LINE__, \
5103 NAME, MATCH_TYPE, COMPLETION_MODE, \
5106 /* Identity checks. */
5107 for (const char *sym : test_symbols)
5109 /* Should be able to match all existing symbols. */
5110 CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
5113 /* Should be able to match all existing symbols with
5115 std::string with_params = std::string (sym) + "(int)";
5116 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
5119 /* Should be able to match all existing symbols with
5120 parameters and qualifiers. */
5121 with_params = std::string (sym) + " ( int ) const";
5122 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
5125 /* This should really find sym, but cp-name-parser.y doesn't
5126 know about lvalue/rvalue qualifiers yet. */
5127 with_params = std::string (sym) + " ( int ) &&";
5128 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
5132 /* Check that the name matching algorithm for completion doesn't get
5133 confused with Latin1 'ÿ' / 0xff. */
5135 static const char str[] = "\377";
5136 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
5137 EXPECT ("\377", "\377\377123"));
5140 /* Check that the increment-last-char in the matching algorithm for
5141 completion doesn't match "t1_fund" when completing "t1_func". */
5143 static const char str[] = "t1_func";
5144 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
5145 EXPECT ("t1_func", "t1_func1"));
5148 /* Check that completion mode works at each prefix of the expected
5151 static const char str[] = "function(int)";
5152 size_t len = strlen (str);
5155 for (size_t i = 1; i < len; i++)
5157 lookup.assign (str, i);
5158 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
5159 EXPECT ("function"));
5163 /* While "w" is a prefix of both components, the match function
5164 should still only be called once. */
5166 CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
5168 CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
5172 /* Same, with a "complicated" symbol. */
5174 static const char str[] = Z_SYM_NAME;
5175 size_t len = strlen (str);
5178 for (size_t i = 1; i < len; i++)
5180 lookup.assign (str, i);
5181 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
5182 EXPECT (Z_SYM_NAME));
5186 /* In FULL mode, an incomplete symbol doesn't match. */
5188 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
5192 /* A complete symbol with parameters matches any overload, since the
5193 index has no overload info. */
5195 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
5196 EXPECT ("std::zfunction", "std::zfunction2"));
5197 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
5198 EXPECT ("std::zfunction", "std::zfunction2"));
5199 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
5200 EXPECT ("std::zfunction", "std::zfunction2"));
5203 /* Check that whitespace is ignored appropriately. A symbol with a
5204 template argument list. */
5206 static const char expected[] = "ns::foo<int>";
5207 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
5209 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
5213 /* Check that whitespace is ignored appropriately. A symbol with a
5214 template argument list that includes a pointer. */
5216 static const char expected[] = "ns::foo<char*>";
5217 /* Try both completion and non-completion modes. */
5218 static const bool completion_mode[2] = {false, true};
5219 for (size_t i = 0; i < 2; i++)
5221 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
5222 completion_mode[i], EXPECT (expected));
5223 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
5224 completion_mode[i], EXPECT (expected));
5226 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
5227 completion_mode[i], EXPECT (expected));
5228 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
5229 completion_mode[i], EXPECT (expected));
5234 /* Check method qualifiers are ignored. */
5235 static const char expected[] = "ns::foo<char*>";
5236 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
5237 symbol_name_match_type::FULL, true, EXPECT (expected));
5238 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
5239 symbol_name_match_type::FULL, true, EXPECT (expected));
5240 CHECK_MATCH ("foo < char * > ( int ) const",
5241 symbol_name_match_type::WILD, true, EXPECT (expected));
5242 CHECK_MATCH ("foo < char * > ( int ) &&",
5243 symbol_name_match_type::WILD, true, EXPECT (expected));
5246 /* Test lookup names that don't match anything. */
5248 CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
5251 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
5255 /* Some wild matching tests, exercising "(anonymous namespace)",
5256 which should not be confused with a parameter list. */
5258 static const char *syms[] = {
5262 "A :: B :: C ( int )",
5267 for (const char *s : syms)
5269 CHECK_MATCH (s, symbol_name_match_type::WILD, false,
5270 EXPECT ("(anonymous namespace)::A::B::C"));
5275 static const char expected[] = "ns2::tmpl<int>::foo2";
5276 CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
5278 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
5282 SELF_CHECK (!any_mismatch);
5291 test_mapped_index_find_name_component_bounds ();
5292 test_dw2_expand_symtabs_matching_symbol ();
5295 }} // namespace selftests::dw2_expand_symtabs_matching
5297 #endif /* GDB_SELF_TEST */
5299 /* If FILE_MATCHER is NULL or if PER_CU has
5300 dwarf2_per_cu_quick_data::MARK set (see
5301 dw_expand_symtabs_matching_file_matcher), expand the CU and call
5302 EXPANSION_NOTIFY on it. */
5305 dw2_expand_symtabs_matching_one
5306 (struct dwarf2_per_cu_data *per_cu,
5307 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5308 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
5310 if (file_matcher == NULL || per_cu->v.quick->mark)
5312 bool symtab_was_null
5313 = (per_cu->v.quick->compunit_symtab == NULL);
5315 dw2_instantiate_symtab (per_cu);
5317 if (expansion_notify != NULL
5319 && per_cu->v.quick->compunit_symtab != NULL)
5320 expansion_notify (per_cu->v.quick->compunit_symtab);
5324 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5325 matched, to expand corresponding CUs that were marked. IDX is the
5326 index of the symbol name that matched. */
5329 dw2_expand_marked_cus
5330 (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5331 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5332 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5335 offset_type *vec, vec_len, vec_idx;
5336 bool global_seen = false;
5337 mapped_index &index = *dwarf2_per_objfile->index_table;
5339 vec = (offset_type *) (index.constant_pool
5340 + MAYBE_SWAP (index.symbol_table[idx].vec));
5341 vec_len = MAYBE_SWAP (vec[0]);
5342 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5344 struct dwarf2_per_cu_data *per_cu;
5345 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5346 /* This value is only valid for index versions >= 7. */
5347 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5348 gdb_index_symbol_kind symbol_kind =
5349 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5350 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5351 /* Only check the symbol attributes if they're present.
5352 Indices prior to version 7 don't record them,
5353 and indices >= 7 may elide them for certain symbols
5354 (gold does this). */
5357 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5359 /* Work around gold/15646. */
5362 if (!is_static && global_seen)
5368 /* Only check the symbol's kind if it has one. */
5373 case VARIABLES_DOMAIN:
5374 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5377 case FUNCTIONS_DOMAIN:
5378 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5382 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5390 /* Don't crash on bad data. */
5391 if (cu_index >= (dwarf2_per_objfile->n_comp_units
5392 + dwarf2_per_objfile->n_type_units))
5394 complaint (&symfile_complaints,
5395 _(".gdb_index entry has bad CU index"
5397 objfile_name (dwarf2_per_objfile->objfile));
5401 per_cu = dw2_get_cutu (dwarf2_per_objfile, cu_index);
5402 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5407 /* If FILE_MATCHER is non-NULL, set all the
5408 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5409 that match FILE_MATCHER. */
5412 dw_expand_symtabs_matching_file_matcher
5413 (struct dwarf2_per_objfile *dwarf2_per_objfile,
5414 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5416 if (file_matcher == NULL)
5419 objfile *const objfile = dwarf2_per_objfile->objfile;
5421 htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5423 NULL, xcalloc, xfree));
5424 htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5426 NULL, xcalloc, xfree));
5428 /* The rule is CUs specify all the files, including those used by
5429 any TU, so there's no need to scan TUs here. */
5431 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
5434 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (dwarf2_per_objfile, i);
5435 struct quick_file_names *file_data;
5440 per_cu->v.quick->mark = 0;
5442 /* We only need to look at symtabs not already expanded. */
5443 if (per_cu->v.quick->compunit_symtab)
5446 file_data = dw2_get_file_names (per_cu);
5447 if (file_data == NULL)
5450 if (htab_find (visited_not_found.get (), file_data) != NULL)
5452 else if (htab_find (visited_found.get (), file_data) != NULL)
5454 per_cu->v.quick->mark = 1;
5458 for (j = 0; j < file_data->num_file_names; ++j)
5460 const char *this_real_name;
5462 if (file_matcher (file_data->file_names[j], false))
5464 per_cu->v.quick->mark = 1;
5468 /* Before we invoke realpath, which can get expensive when many
5469 files are involved, do a quick comparison of the basenames. */
5470 if (!basenames_may_differ
5471 && !file_matcher (lbasename (file_data->file_names[j]),
5475 this_real_name = dw2_get_real_path (objfile, file_data, j);
5476 if (file_matcher (this_real_name, false))
5478 per_cu->v.quick->mark = 1;
5483 slot = htab_find_slot (per_cu->v.quick->mark
5484 ? visited_found.get ()
5485 : visited_not_found.get (),
5492 dw2_expand_symtabs_matching
5493 (struct objfile *objfile,
5494 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5495 const lookup_name_info &lookup_name,
5496 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5497 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5498 enum search_domain kind)
5500 struct dwarf2_per_objfile *dwarf2_per_objfile
5501 = get_dwarf2_per_objfile (objfile);
5503 /* index_table is NULL if OBJF_READNOW. */
5504 if (!dwarf2_per_objfile->index_table)
5507 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5509 mapped_index &index = *dwarf2_per_objfile->index_table;
5511 dw2_expand_symtabs_matching_symbol (index, lookup_name,
5513 kind, [&] (offset_type idx)
5515 dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5516 expansion_notify, kind);
5520 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5523 static struct compunit_symtab *
5524 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5529 if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5530 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5533 if (cust->includes == NULL)
5536 for (i = 0; cust->includes[i]; ++i)
5538 struct compunit_symtab *s = cust->includes[i];
5540 s = recursively_find_pc_sect_compunit_symtab (s, pc);
5548 static struct compunit_symtab *
5549 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5550 struct bound_minimal_symbol msymbol,
5552 struct obj_section *section,
5555 struct dwarf2_per_cu_data *data;
5556 struct compunit_symtab *result;
5558 if (!objfile->psymtabs_addrmap)
5561 data = (struct dwarf2_per_cu_data *) addrmap_find (objfile->psymtabs_addrmap,
5566 if (warn_if_readin && data->v.quick->compunit_symtab)
5567 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5568 paddress (get_objfile_arch (objfile), pc));
5571 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data),
5573 gdb_assert (result != NULL);
5578 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5579 void *data, int need_fullname)
5581 struct dwarf2_per_objfile *dwarf2_per_objfile
5582 = get_dwarf2_per_objfile (objfile);
5584 if (!dwarf2_per_objfile->filenames_cache)
5586 dwarf2_per_objfile->filenames_cache.emplace ();
5588 htab_up visited (htab_create_alloc (10,
5589 htab_hash_pointer, htab_eq_pointer,
5590 NULL, xcalloc, xfree));
5592 /* The rule is CUs specify all the files, including those used
5593 by any TU, so there's no need to scan TUs here. We can
5594 ignore file names coming from already-expanded CUs. */
5596 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
5598 dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
5600 if (per_cu->v.quick->compunit_symtab)
5602 void **slot = htab_find_slot (visited.get (),
5603 per_cu->v.quick->file_names,
5606 *slot = per_cu->v.quick->file_names;
5610 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
5612 dwarf2_per_cu_data *per_cu = dw2_get_cu (dwarf2_per_objfile, i);
5613 struct quick_file_names *file_data;
5616 /* We only need to look at symtabs not already expanded. */
5617 if (per_cu->v.quick->compunit_symtab)
5620 file_data = dw2_get_file_names (per_cu);
5621 if (file_data == NULL)
5624 slot = htab_find_slot (visited.get (), file_data, INSERT);
5627 /* Already visited. */
5632 for (int j = 0; j < file_data->num_file_names; ++j)
5634 const char *filename = file_data->file_names[j];
5635 dwarf2_per_objfile->filenames_cache->seen (filename);
5640 dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5642 gdb::unique_xmalloc_ptr<char> this_real_name;
5645 this_real_name = gdb_realpath (filename);
5646 (*fun) (filename, this_real_name.get (), data);
5651 dw2_has_symbols (struct objfile *objfile)
5656 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5659 dw2_find_last_source_symtab,
5660 dw2_forget_cached_source_info,
5661 dw2_map_symtabs_matching_filename,
5666 dw2_expand_symtabs_for_function,
5667 dw2_expand_all_symtabs,
5668 dw2_expand_symtabs_with_fullname,
5669 dw2_map_matching_symbols,
5670 dw2_expand_symtabs_matching,
5671 dw2_find_pc_sect_compunit_symtab,
5673 dw2_map_symbol_filenames
5676 /* DWARF-5 debug_names reader. */
5678 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5679 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5681 /* A helper function that reads the .debug_names section in SECTION
5682 and fills in MAP. FILENAME is the name of the file containing the
5683 section; it is used for error reporting.
5685 Returns true if all went well, false otherwise. */
5688 read_debug_names_from_section (struct objfile *objfile,
5689 const char *filename,
5690 struct dwarf2_section_info *section,
5691 mapped_debug_names &map)
5693 if (dwarf2_section_empty_p (section))
5696 /* Older elfutils strip versions could keep the section in the main
5697 executable while splitting it for the separate debug info file. */
5698 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5701 dwarf2_read_section (objfile, section);
5703 map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5705 const gdb_byte *addr = section->buffer;
5707 bfd *const abfd = get_section_bfd_owner (section);
5709 unsigned int bytes_read;
5710 LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5713 map.dwarf5_is_dwarf64 = bytes_read != 4;
5714 map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5715 if (bytes_read + length != section->size)
5717 /* There may be multiple per-CU indices. */
5718 warning (_("Section .debug_names in %s length %s does not match "
5719 "section length %s, ignoring .debug_names."),
5720 filename, plongest (bytes_read + length),
5721 pulongest (section->size));
5725 /* The version number. */
5726 uint16_t version = read_2_bytes (abfd, addr);
5730 warning (_("Section .debug_names in %s has unsupported version %d, "
5731 "ignoring .debug_names."),
5737 uint16_t padding = read_2_bytes (abfd, addr);
5741 warning (_("Section .debug_names in %s has unsupported padding %d, "
5742 "ignoring .debug_names."),
5747 /* comp_unit_count - The number of CUs in the CU list. */
5748 map.cu_count = read_4_bytes (abfd, addr);
5751 /* local_type_unit_count - The number of TUs in the local TU
5753 map.tu_count = read_4_bytes (abfd, addr);
5756 /* foreign_type_unit_count - The number of TUs in the foreign TU
5758 uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5760 if (foreign_tu_count != 0)
5762 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5763 "ignoring .debug_names."),
5764 filename, static_cast<unsigned long> (foreign_tu_count));
5768 /* bucket_count - The number of hash buckets in the hash lookup
5770 map.bucket_count = read_4_bytes (abfd, addr);
5773 /* name_count - The number of unique names in the index. */
5774 map.name_count = read_4_bytes (abfd, addr);
5777 /* abbrev_table_size - The size in bytes of the abbreviations
5779 uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5782 /* augmentation_string_size - The size in bytes of the augmentation
5783 string. This value is rounded up to a multiple of 4. */
5784 uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5786 map.augmentation_is_gdb = ((augmentation_string_size
5787 == sizeof (dwarf5_augmentation))
5788 && memcmp (addr, dwarf5_augmentation,
5789 sizeof (dwarf5_augmentation)) == 0);
5790 augmentation_string_size += (-augmentation_string_size) & 3;
5791 addr += augmentation_string_size;
5794 map.cu_table_reordered = addr;
5795 addr += map.cu_count * map.offset_size;
5797 /* List of Local TUs */
5798 map.tu_table_reordered = addr;
5799 addr += map.tu_count * map.offset_size;
5801 /* Hash Lookup Table */
5802 map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5803 addr += map.bucket_count * 4;
5804 map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5805 addr += map.name_count * 4;
5808 map.name_table_string_offs_reordered = addr;
5809 addr += map.name_count * map.offset_size;
5810 map.name_table_entry_offs_reordered = addr;
5811 addr += map.name_count * map.offset_size;
5813 const gdb_byte *abbrev_table_start = addr;
5816 unsigned int bytes_read;
5817 const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5822 const auto insertpair
5823 = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5824 if (!insertpair.second)
5826 warning (_("Section .debug_names in %s has duplicate index %s, "
5827 "ignoring .debug_names."),
5828 filename, pulongest (index_num));
5831 mapped_debug_names::index_val &indexval = insertpair.first->second;
5832 indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5837 mapped_debug_names::index_val::attr attr;
5838 attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5840 attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5842 if (attr.form == DW_FORM_implicit_const)
5844 attr.implicit_const = read_signed_leb128 (abfd, addr,
5848 if (attr.dw_idx == 0 && attr.form == 0)
5850 indexval.attr_vec.push_back (std::move (attr));
5853 if (addr != abbrev_table_start + abbrev_table_size)
5855 warning (_("Section .debug_names in %s has abbreviation_table "
5856 "of size %zu vs. written as %u, ignoring .debug_names."),
5857 filename, addr - abbrev_table_start, abbrev_table_size);
5860 map.entry_pool = addr;
5865 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5869 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5870 const mapped_debug_names &map,
5871 dwarf2_section_info §ion,
5872 bool is_dwz, int base_offset)
5874 sect_offset sect_off_prev;
5875 for (uint32_t i = 0; i <= map.cu_count; ++i)
5877 sect_offset sect_off_next;
5878 if (i < map.cu_count)
5881 = (sect_offset) (extract_unsigned_integer
5882 (map.cu_table_reordered + i * map.offset_size,
5884 map.dwarf5_byte_order));
5887 sect_off_next = (sect_offset) section.size;
5890 const ULONGEST length = sect_off_next - sect_off_prev;
5891 dwarf2_per_objfile->all_comp_units[base_offset + (i - 1)]
5892 = create_cu_from_index_list (dwarf2_per_objfile, §ion, is_dwz,
5893 sect_off_prev, length);
5895 sect_off_prev = sect_off_next;
5899 /* Read the CU list from the mapped index, and use it to create all
5900 the CU objects for this dwarf2_per_objfile. */
5903 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5904 const mapped_debug_names &map,
5905 const mapped_debug_names &dwz_map)
5907 struct objfile *objfile = dwarf2_per_objfile->objfile;
5909 dwarf2_per_objfile->n_comp_units = map.cu_count + dwz_map.cu_count;
5910 dwarf2_per_objfile->all_comp_units
5911 = XOBNEWVEC (&objfile->objfile_obstack, struct dwarf2_per_cu_data *,
5912 dwarf2_per_objfile->n_comp_units);
5914 create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5915 dwarf2_per_objfile->info,
5917 0 /* base_offset */);
5919 if (dwz_map.cu_count == 0)
5922 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5923 create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5925 map.cu_count /* base_offset */);
5928 /* Read .debug_names. If everything went ok, initialize the "quick"
5929 elements of all the CUs and return true. Otherwise, return false. */
5932 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5934 mapped_debug_names local_map (dwarf2_per_objfile);
5935 mapped_debug_names dwz_map (dwarf2_per_objfile);
5936 struct objfile *objfile = dwarf2_per_objfile->objfile;
5938 if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5939 &dwarf2_per_objfile->debug_names,
5943 /* Don't use the index if it's empty. */
5944 if (local_map.name_count == 0)
5947 /* If there is a .dwz file, read it so we can get its CU list as
5949 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5952 if (!read_debug_names_from_section (objfile,
5953 bfd_get_filename (dwz->dwz_bfd),
5954 &dwz->debug_names, dwz_map))
5956 warning (_("could not read '.debug_names' section from %s; skipping"),
5957 bfd_get_filename (dwz->dwz_bfd));
5962 create_cus_from_debug_names (dwarf2_per_objfile, local_map, dwz_map);
5964 if (local_map.tu_count != 0)
5966 /* We can only handle a single .debug_types when we have an
5968 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5971 dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5972 dwarf2_per_objfile->types, 0);
5974 create_signatured_type_table_from_debug_names
5975 (dwarf2_per_objfile, local_map, section, &dwarf2_per_objfile->abbrev);
5978 create_addrmap_from_aranges (dwarf2_per_objfile,
5979 &dwarf2_per_objfile->debug_aranges);
5981 dwarf2_per_objfile->debug_names_table.reset
5982 (new mapped_debug_names (dwarf2_per_objfile));
5983 *dwarf2_per_objfile->debug_names_table = std::move (local_map);
5984 dwarf2_per_objfile->using_index = 1;
5985 dwarf2_per_objfile->quick_file_names_table =
5986 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
5991 /* Symbol name hashing function as specified by DWARF-5. */
5994 dwarf5_djb_hash (const char *str_)
5996 const unsigned char *str = (const unsigned char *) str_;
5998 /* Note: tolower here ignores UTF-8, which isn't fully compliant.
5999 See http://dwarfstd.org/ShowIssue.php?issue=161027.1. */
6001 uint32_t hash = 5381;
6002 while (int c = *str++)
6003 hash = hash * 33 + tolower (c);
6007 /* Type used to manage iterating over all CUs looking for a symbol for
6010 class dw2_debug_names_iterator
6013 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
6014 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
6015 dw2_debug_names_iterator (const mapped_debug_names &map,
6016 bool want_specific_block,
6017 block_enum block_index, domain_enum domain,
6019 : m_map (map), m_want_specific_block (want_specific_block),
6020 m_block_index (block_index), m_domain (domain),
6021 m_addr (find_vec_in_debug_names (map, name))
6024 dw2_debug_names_iterator (const mapped_debug_names &map,
6025 search_domain search, uint32_t namei)
6028 m_addr (find_vec_in_debug_names (map, namei))
6031 /* Return the next matching CU or NULL if there are no more. */
6032 dwarf2_per_cu_data *next ();
6035 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
6037 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
6040 /* The internalized form of .debug_names. */
6041 const mapped_debug_names &m_map;
6043 /* If true, only look for symbols that match BLOCK_INDEX. */
6044 const bool m_want_specific_block = false;
6046 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
6047 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
6049 const block_enum m_block_index = FIRST_LOCAL_BLOCK;
6051 /* The kind of symbol we're looking for. */
6052 const domain_enum m_domain = UNDEF_DOMAIN;
6053 const search_domain m_search = ALL_DOMAIN;
6055 /* The list of CUs from the index entry of the symbol, or NULL if
6057 const gdb_byte *m_addr;
6061 mapped_debug_names::namei_to_name (uint32_t namei) const
6063 const ULONGEST namei_string_offs
6064 = extract_unsigned_integer ((name_table_string_offs_reordered
6065 + namei * offset_size),
6068 return read_indirect_string_at_offset
6069 (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
6072 /* Find a slot in .debug_names for the object named NAME. If NAME is
6073 found, return pointer to its pool data. If NAME cannot be found,
6077 dw2_debug_names_iterator::find_vec_in_debug_names
6078 (const mapped_debug_names &map, const char *name)
6080 int (*cmp) (const char *, const char *);
6082 if (current_language->la_language == language_cplus
6083 || current_language->la_language == language_fortran
6084 || current_language->la_language == language_d)
6086 /* NAME is already canonical. Drop any qualifiers as
6087 .debug_names does not contain any. */
6089 if (strchr (name, '(') != NULL)
6091 gdb::unique_xmalloc_ptr<char> without_params
6092 = cp_remove_params (name);
6094 if (without_params != NULL)
6096 name = without_params.get();
6101 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
6103 const uint32_t full_hash = dwarf5_djb_hash (name);
6105 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
6106 (map.bucket_table_reordered
6107 + (full_hash % map.bucket_count)), 4,
6108 map.dwarf5_byte_order);
6112 if (namei >= map.name_count)
6114 complaint (&symfile_complaints,
6115 _("Wrong .debug_names with name index %u but name_count=%u "
6117 namei, map.name_count,
6118 objfile_name (map.dwarf2_per_objfile->objfile));
6124 const uint32_t namei_full_hash
6125 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
6126 (map.hash_table_reordered + namei), 4,
6127 map.dwarf5_byte_order);
6128 if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
6131 if (full_hash == namei_full_hash)
6133 const char *const namei_string = map.namei_to_name (namei);
6135 #if 0 /* An expensive sanity check. */
6136 if (namei_full_hash != dwarf5_djb_hash (namei_string))
6138 complaint (&symfile_complaints,
6139 _("Wrong .debug_names hash for string at index %u "
6141 namei, objfile_name (dwarf2_per_objfile->objfile));
6146 if (cmp (namei_string, name) == 0)
6148 const ULONGEST namei_entry_offs
6149 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
6150 + namei * map.offset_size),
6151 map.offset_size, map.dwarf5_byte_order);
6152 return map.entry_pool + namei_entry_offs;
6157 if (namei >= map.name_count)
6163 dw2_debug_names_iterator::find_vec_in_debug_names
6164 (const mapped_debug_names &map, uint32_t namei)
6166 if (namei >= map.name_count)
6168 complaint (&symfile_complaints,
6169 _("Wrong .debug_names with name index %u but name_count=%u "
6171 namei, map.name_count,
6172 objfile_name (map.dwarf2_per_objfile->objfile));
6176 const ULONGEST namei_entry_offs
6177 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
6178 + namei * map.offset_size),
6179 map.offset_size, map.dwarf5_byte_order);
6180 return map.entry_pool + namei_entry_offs;
6183 /* See dw2_debug_names_iterator. */
6185 dwarf2_per_cu_data *
6186 dw2_debug_names_iterator::next ()
6191 struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
6192 struct objfile *objfile = dwarf2_per_objfile->objfile;
6193 bfd *const abfd = objfile->obfd;
6197 unsigned int bytes_read;
6198 const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
6199 m_addr += bytes_read;
6203 const auto indexval_it = m_map.abbrev_map.find (abbrev);
6204 if (indexval_it == m_map.abbrev_map.cend ())
6206 complaint (&symfile_complaints,
6207 _("Wrong .debug_names undefined abbrev code %s "
6209 pulongest (abbrev), objfile_name (objfile));
6212 const mapped_debug_names::index_val &indexval = indexval_it->second;
6213 bool have_is_static = false;
6215 dwarf2_per_cu_data *per_cu = NULL;
6216 for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
6221 case DW_FORM_implicit_const:
6222 ull = attr.implicit_const;
6224 case DW_FORM_flag_present:
6228 ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
6229 m_addr += bytes_read;
6232 complaint (&symfile_complaints,
6233 _("Unsupported .debug_names form %s [in module %s]"),
6234 dwarf_form_name (attr.form),
6235 objfile_name (objfile));
6238 switch (attr.dw_idx)
6240 case DW_IDX_compile_unit:
6241 /* Don't crash on bad data. */
6242 if (ull >= dwarf2_per_objfile->n_comp_units)
6244 complaint (&symfile_complaints,
6245 _(".debug_names entry has bad CU index %s"
6248 objfile_name (dwarf2_per_objfile->objfile));
6251 per_cu = dw2_get_cutu (dwarf2_per_objfile, ull);
6253 case DW_IDX_type_unit:
6254 /* Don't crash on bad data. */
6255 if (ull >= dwarf2_per_objfile->n_type_units)
6257 complaint (&symfile_complaints,
6258 _(".debug_names entry has bad TU index %s"
6261 objfile_name (dwarf2_per_objfile->objfile));
6264 per_cu = dw2_get_cutu (dwarf2_per_objfile,
6265 dwarf2_per_objfile->n_comp_units + ull);
6267 case DW_IDX_GNU_internal:
6268 if (!m_map.augmentation_is_gdb)
6270 have_is_static = true;
6273 case DW_IDX_GNU_external:
6274 if (!m_map.augmentation_is_gdb)
6276 have_is_static = true;
6282 /* Skip if already read in. */
6283 if (per_cu->v.quick->compunit_symtab)
6286 /* Check static vs global. */
6289 const bool want_static = m_block_index != GLOBAL_BLOCK;
6290 if (m_want_specific_block && want_static != is_static)
6294 /* Match dw2_symtab_iter_next, symbol_kind
6295 and debug_names::psymbol_tag. */
6299 switch (indexval.dwarf_tag)
6301 case DW_TAG_variable:
6302 case DW_TAG_subprogram:
6303 /* Some types are also in VAR_DOMAIN. */
6304 case DW_TAG_typedef:
6305 case DW_TAG_structure_type:
6312 switch (indexval.dwarf_tag)
6314 case DW_TAG_typedef:
6315 case DW_TAG_structure_type:
6322 switch (indexval.dwarf_tag)
6325 case DW_TAG_variable:
6335 /* Match dw2_expand_symtabs_matching, symbol_kind and
6336 debug_names::psymbol_tag. */
6339 case VARIABLES_DOMAIN:
6340 switch (indexval.dwarf_tag)
6342 case DW_TAG_variable:
6348 case FUNCTIONS_DOMAIN:
6349 switch (indexval.dwarf_tag)
6351 case DW_TAG_subprogram:
6358 switch (indexval.dwarf_tag)
6360 case DW_TAG_typedef:
6361 case DW_TAG_structure_type:
6374 static struct compunit_symtab *
6375 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6376 const char *name, domain_enum domain)
6378 const block_enum block_index = static_cast<block_enum> (block_index_int);
6379 struct dwarf2_per_objfile *dwarf2_per_objfile
6380 = get_dwarf2_per_objfile (objfile);
6382 const auto &mapp = dwarf2_per_objfile->debug_names_table;
6385 /* index is NULL if OBJF_READNOW. */
6388 const auto &map = *mapp;
6390 dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6391 block_index, domain, name);
6393 struct compunit_symtab *stab_best = NULL;
6394 struct dwarf2_per_cu_data *per_cu;
6395 while ((per_cu = iter.next ()) != NULL)
6397 struct symbol *sym, *with_opaque = NULL;
6398 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu);
6399 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6400 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6402 sym = block_find_symbol (block, name, domain,
6403 block_find_non_opaque_type_preferred,
6406 /* Some caution must be observed with overloaded functions and
6407 methods, since the index will not contain any overload
6408 information (but NAME might contain it). */
6411 && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6413 if (with_opaque != NULL
6414 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6417 /* Keep looking through other CUs. */
6423 /* This dumps minimal information about .debug_names. It is called
6424 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6425 uses this to verify that .debug_names has been loaded. */
6428 dw2_debug_names_dump (struct objfile *objfile)
6430 struct dwarf2_per_objfile *dwarf2_per_objfile
6431 = get_dwarf2_per_objfile (objfile);
6433 gdb_assert (dwarf2_per_objfile->using_index);
6434 printf_filtered (".debug_names:");
6435 if (dwarf2_per_objfile->debug_names_table)
6436 printf_filtered (" exists\n");
6438 printf_filtered (" faked for \"readnow\"\n");
6439 printf_filtered ("\n");
6443 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6444 const char *func_name)
6446 struct dwarf2_per_objfile *dwarf2_per_objfile
6447 = get_dwarf2_per_objfile (objfile);
6449 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6450 if (dwarf2_per_objfile->debug_names_table)
6452 const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6454 /* Note: It doesn't matter what we pass for block_index here. */
6455 dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6456 GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6458 struct dwarf2_per_cu_data *per_cu;
6459 while ((per_cu = iter.next ()) != NULL)
6460 dw2_instantiate_symtab (per_cu);
6465 dw2_debug_names_expand_symtabs_matching
6466 (struct objfile *objfile,
6467 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6468 const lookup_name_info &lookup_name,
6469 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6470 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6471 enum search_domain kind)
6473 struct dwarf2_per_objfile *dwarf2_per_objfile
6474 = get_dwarf2_per_objfile (objfile);
6476 /* debug_names_table is NULL if OBJF_READNOW. */
6477 if (!dwarf2_per_objfile->debug_names_table)
6480 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6482 mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6484 dw2_expand_symtabs_matching_symbol (map, lookup_name,
6486 kind, [&] (offset_type namei)
6488 /* The name was matched, now expand corresponding CUs that were
6490 dw2_debug_names_iterator iter (map, kind, namei);
6492 struct dwarf2_per_cu_data *per_cu;
6493 while ((per_cu = iter.next ()) != NULL)
6494 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6499 const struct quick_symbol_functions dwarf2_debug_names_functions =
6502 dw2_find_last_source_symtab,
6503 dw2_forget_cached_source_info,
6504 dw2_map_symtabs_matching_filename,
6505 dw2_debug_names_lookup_symbol,
6507 dw2_debug_names_dump,
6509 dw2_debug_names_expand_symtabs_for_function,
6510 dw2_expand_all_symtabs,
6511 dw2_expand_symtabs_with_fullname,
6512 dw2_map_matching_symbols,
6513 dw2_debug_names_expand_symtabs_matching,
6514 dw2_find_pc_sect_compunit_symtab,
6516 dw2_map_symbol_filenames
6519 /* See symfile.h. */
6522 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6524 struct dwarf2_per_objfile *dwarf2_per_objfile
6525 = get_dwarf2_per_objfile (objfile);
6527 /* If we're about to read full symbols, don't bother with the
6528 indices. In this case we also don't care if some other debug
6529 format is making psymtabs, because they are all about to be
6531 if ((objfile->flags & OBJF_READNOW))
6535 dwarf2_per_objfile->using_index = 1;
6536 create_all_comp_units (dwarf2_per_objfile);
6537 create_all_type_units (dwarf2_per_objfile);
6538 dwarf2_per_objfile->quick_file_names_table =
6539 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
6541 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
6542 + dwarf2_per_objfile->n_type_units); ++i)
6544 dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
6546 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6547 struct dwarf2_per_cu_quick_data);
6550 /* Return 1 so that gdb sees the "quick" functions. However,
6551 these functions will be no-ops because we will have expanded
6553 *index_kind = dw_index_kind::GDB_INDEX;
6557 if (dwarf2_read_debug_names (dwarf2_per_objfile))
6559 *index_kind = dw_index_kind::DEBUG_NAMES;
6563 if (dwarf2_read_index (objfile))
6565 *index_kind = dw_index_kind::GDB_INDEX;
6574 /* Build a partial symbol table. */
6577 dwarf2_build_psymtabs (struct objfile *objfile)
6579 struct dwarf2_per_objfile *dwarf2_per_objfile
6580 = get_dwarf2_per_objfile (objfile);
6582 if (objfile->global_psymbols.capacity () == 0
6583 && objfile->static_psymbols.capacity () == 0)
6584 init_psymbol_list (objfile, 1024);
6588 /* This isn't really ideal: all the data we allocate on the
6589 objfile's obstack is still uselessly kept around. However,
6590 freeing it seems unsafe. */
6591 psymtab_discarder psymtabs (objfile);
6592 dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6595 CATCH (except, RETURN_MASK_ERROR)
6597 exception_print (gdb_stderr, except);
6602 /* Return the total length of the CU described by HEADER. */
6605 get_cu_length (const struct comp_unit_head *header)
6607 return header->initial_length_size + header->length;
6610 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6613 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6615 sect_offset bottom = cu_header->sect_off;
6616 sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6618 return sect_off >= bottom && sect_off < top;
6621 /* Find the base address of the compilation unit for range lists and
6622 location lists. It will normally be specified by DW_AT_low_pc.
6623 In DWARF-3 draft 4, the base address could be overridden by
6624 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6625 compilation units with discontinuous ranges. */
6628 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6630 struct attribute *attr;
6633 cu->base_address = 0;
6635 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6638 cu->base_address = attr_value_as_address (attr);
6643 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6646 cu->base_address = attr_value_as_address (attr);
6652 /* Read in the comp unit header information from the debug_info at info_ptr.
6653 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6654 NOTE: This leaves members offset, first_die_offset to be filled in
6657 static const gdb_byte *
6658 read_comp_unit_head (struct comp_unit_head *cu_header,
6659 const gdb_byte *info_ptr,
6660 struct dwarf2_section_info *section,
6661 rcuh_kind section_kind)
6664 unsigned int bytes_read;
6665 const char *filename = get_section_file_name (section);
6666 bfd *abfd = get_section_bfd_owner (section);
6668 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6669 cu_header->initial_length_size = bytes_read;
6670 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6671 info_ptr += bytes_read;
6672 cu_header->version = read_2_bytes (abfd, info_ptr);
6674 if (cu_header->version < 5)
6675 switch (section_kind)
6677 case rcuh_kind::COMPILE:
6678 cu_header->unit_type = DW_UT_compile;
6680 case rcuh_kind::TYPE:
6681 cu_header->unit_type = DW_UT_type;
6684 internal_error (__FILE__, __LINE__,
6685 _("read_comp_unit_head: invalid section_kind"));
6689 cu_header->unit_type = static_cast<enum dwarf_unit_type>
6690 (read_1_byte (abfd, info_ptr));
6692 switch (cu_header->unit_type)
6695 if (section_kind != rcuh_kind::COMPILE)
6696 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6697 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6701 section_kind = rcuh_kind::TYPE;
6704 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6705 "(is %d, should be %d or %d) [in module %s]"),
6706 cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6709 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6712 cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6715 info_ptr += bytes_read;
6716 if (cu_header->version < 5)
6718 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6721 signed_addr = bfd_get_sign_extend_vma (abfd);
6722 if (signed_addr < 0)
6723 internal_error (__FILE__, __LINE__,
6724 _("read_comp_unit_head: dwarf from non elf file"));
6725 cu_header->signed_addr_p = signed_addr;
6727 if (section_kind == rcuh_kind::TYPE)
6729 LONGEST type_offset;
6731 cu_header->signature = read_8_bytes (abfd, info_ptr);
6734 type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6735 info_ptr += bytes_read;
6736 cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6737 if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6738 error (_("Dwarf Error: Too big type_offset in compilation unit "
6739 "header (is %s) [in module %s]"), plongest (type_offset),
6746 /* Helper function that returns the proper abbrev section for
6749 static struct dwarf2_section_info *
6750 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6752 struct dwarf2_section_info *abbrev;
6753 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6755 if (this_cu->is_dwz)
6756 abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6758 abbrev = &dwarf2_per_objfile->abbrev;
6763 /* Subroutine of read_and_check_comp_unit_head and
6764 read_and_check_type_unit_head to simplify them.
6765 Perform various error checking on the header. */
6768 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6769 struct comp_unit_head *header,
6770 struct dwarf2_section_info *section,
6771 struct dwarf2_section_info *abbrev_section)
6773 const char *filename = get_section_file_name (section);
6775 if (header->version < 2 || header->version > 5)
6776 error (_("Dwarf Error: wrong version in compilation unit header "
6777 "(is %d, should be 2, 3, 4 or 5) [in module %s]"), header->version,
6780 if (to_underlying (header->abbrev_sect_off)
6781 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6782 error (_("Dwarf Error: bad offset (0x%x) in compilation unit header "
6783 "(offset 0x%x + 6) [in module %s]"),
6784 to_underlying (header->abbrev_sect_off),
6785 to_underlying (header->sect_off),
6788 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6789 avoid potential 32-bit overflow. */
6790 if (((ULONGEST) header->sect_off + get_cu_length (header))
6792 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6793 "(offset 0x%x + 0) [in module %s]"),
6794 header->length, to_underlying (header->sect_off),
6798 /* Read in a CU/TU header and perform some basic error checking.
6799 The contents of the header are stored in HEADER.
6800 The result is a pointer to the start of the first DIE. */
6802 static const gdb_byte *
6803 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6804 struct comp_unit_head *header,
6805 struct dwarf2_section_info *section,
6806 struct dwarf2_section_info *abbrev_section,
6807 const gdb_byte *info_ptr,
6808 rcuh_kind section_kind)
6810 const gdb_byte *beg_of_comp_unit = info_ptr;
6812 header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6814 info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6816 header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6818 error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6824 /* Fetch the abbreviation table offset from a comp or type unit header. */
6827 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6828 struct dwarf2_section_info *section,
6829 sect_offset sect_off)
6831 bfd *abfd = get_section_bfd_owner (section);
6832 const gdb_byte *info_ptr;
6833 unsigned int initial_length_size, offset_size;
6836 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6837 info_ptr = section->buffer + to_underlying (sect_off);
6838 read_initial_length (abfd, info_ptr, &initial_length_size);
6839 offset_size = initial_length_size == 4 ? 4 : 8;
6840 info_ptr += initial_length_size;
6842 version = read_2_bytes (abfd, info_ptr);
6846 /* Skip unit type and address size. */
6850 return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6853 /* Allocate a new partial symtab for file named NAME and mark this new
6854 partial symtab as being an include of PST. */
6857 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6858 struct objfile *objfile)
6860 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6862 if (!IS_ABSOLUTE_PATH (subpst->filename))
6864 /* It shares objfile->objfile_obstack. */
6865 subpst->dirname = pst->dirname;
6868 subpst->textlow = 0;
6869 subpst->texthigh = 0;
6871 subpst->dependencies
6872 = XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
6873 subpst->dependencies[0] = pst;
6874 subpst->number_of_dependencies = 1;
6876 subpst->globals_offset = 0;
6877 subpst->n_global_syms = 0;
6878 subpst->statics_offset = 0;
6879 subpst->n_static_syms = 0;
6880 subpst->compunit_symtab = NULL;
6881 subpst->read_symtab = pst->read_symtab;
6884 /* No private part is necessary for include psymtabs. This property
6885 can be used to differentiate between such include psymtabs and
6886 the regular ones. */
6887 subpst->read_symtab_private = NULL;
6890 /* Read the Line Number Program data and extract the list of files
6891 included by the source file represented by PST. Build an include
6892 partial symtab for each of these included files. */
6895 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6896 struct die_info *die,
6897 struct partial_symtab *pst)
6900 struct attribute *attr;
6902 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6904 lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6906 return; /* No linetable, so no includes. */
6908 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
6909 dwarf_decode_lines (lh.get (), pst->dirname, cu, pst, pst->textlow, 1);
6913 hash_signatured_type (const void *item)
6915 const struct signatured_type *sig_type
6916 = (const struct signatured_type *) item;
6918 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6919 return sig_type->signature;
6923 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6925 const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6926 const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6928 return lhs->signature == rhs->signature;
6931 /* Allocate a hash table for signatured types. */
6934 allocate_signatured_type_table (struct objfile *objfile)
6936 return htab_create_alloc_ex (41,
6937 hash_signatured_type,
6940 &objfile->objfile_obstack,
6941 hashtab_obstack_allocate,
6942 dummy_obstack_deallocate);
6945 /* A helper function to add a signatured type CU to a table. */
6948 add_signatured_type_cu_to_table (void **slot, void *datum)
6950 struct signatured_type *sigt = (struct signatured_type *) *slot;
6951 struct signatured_type ***datap = (struct signatured_type ***) datum;
6959 /* A helper for create_debug_types_hash_table. Read types from SECTION
6960 and fill them into TYPES_HTAB. It will process only type units,
6961 therefore DW_UT_type. */
6964 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6965 struct dwo_file *dwo_file,
6966 dwarf2_section_info *section, htab_t &types_htab,
6967 rcuh_kind section_kind)
6969 struct objfile *objfile = dwarf2_per_objfile->objfile;
6970 struct dwarf2_section_info *abbrev_section;
6972 const gdb_byte *info_ptr, *end_ptr;
6974 abbrev_section = (dwo_file != NULL
6975 ? &dwo_file->sections.abbrev
6976 : &dwarf2_per_objfile->abbrev);
6978 if (dwarf_read_debug)
6979 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6980 get_section_name (section),
6981 get_section_file_name (abbrev_section));
6983 dwarf2_read_section (objfile, section);
6984 info_ptr = section->buffer;
6986 if (info_ptr == NULL)
6989 /* We can't set abfd until now because the section may be empty or
6990 not present, in which case the bfd is unknown. */
6991 abfd = get_section_bfd_owner (section);
6993 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6994 because we don't need to read any dies: the signature is in the
6997 end_ptr = info_ptr + section->size;
6998 while (info_ptr < end_ptr)
7000 struct signatured_type *sig_type;
7001 struct dwo_unit *dwo_tu;
7003 const gdb_byte *ptr = info_ptr;
7004 struct comp_unit_head header;
7005 unsigned int length;
7007 sect_offset sect_off = (sect_offset) (ptr - section->buffer);
7009 /* Initialize it due to a false compiler warning. */
7010 header.signature = -1;
7011 header.type_cu_offset_in_tu = (cu_offset) -1;
7013 /* We need to read the type's signature in order to build the hash
7014 table, but we don't need anything else just yet. */
7016 ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
7017 abbrev_section, ptr, section_kind);
7019 length = get_cu_length (&header);
7021 /* Skip dummy type units. */
7022 if (ptr >= info_ptr + length
7023 || peek_abbrev_code (abfd, ptr) == 0
7024 || header.unit_type != DW_UT_type)
7030 if (types_htab == NULL)
7033 types_htab = allocate_dwo_unit_table (objfile);
7035 types_htab = allocate_signatured_type_table (objfile);
7041 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7043 dwo_tu->dwo_file = dwo_file;
7044 dwo_tu->signature = header.signature;
7045 dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
7046 dwo_tu->section = section;
7047 dwo_tu->sect_off = sect_off;
7048 dwo_tu->length = length;
7052 /* N.B.: type_offset is not usable if this type uses a DWO file.
7053 The real type_offset is in the DWO file. */
7055 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7056 struct signatured_type);
7057 sig_type->signature = header.signature;
7058 sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
7059 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
7060 sig_type->per_cu.is_debug_types = 1;
7061 sig_type->per_cu.section = section;
7062 sig_type->per_cu.sect_off = sect_off;
7063 sig_type->per_cu.length = length;
7066 slot = htab_find_slot (types_htab,
7067 dwo_file ? (void*) dwo_tu : (void *) sig_type,
7069 gdb_assert (slot != NULL);
7072 sect_offset dup_sect_off;
7076 const struct dwo_unit *dup_tu
7077 = (const struct dwo_unit *) *slot;
7079 dup_sect_off = dup_tu->sect_off;
7083 const struct signatured_type *dup_tu
7084 = (const struct signatured_type *) *slot;
7086 dup_sect_off = dup_tu->per_cu.sect_off;
7089 complaint (&symfile_complaints,
7090 _("debug type entry at offset 0x%x is duplicate to"
7091 " the entry at offset 0x%x, signature %s"),
7092 to_underlying (sect_off), to_underlying (dup_sect_off),
7093 hex_string (header.signature));
7095 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
7097 if (dwarf_read_debug > 1)
7098 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature %s\n",
7099 to_underlying (sect_off),
7100 hex_string (header.signature));
7106 /* Create the hash table of all entries in the .debug_types
7107 (or .debug_types.dwo) section(s).
7108 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
7109 otherwise it is NULL.
7111 The result is a pointer to the hash table or NULL if there are no types.
7113 Note: This function processes DWO files only, not DWP files. */
7116 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
7117 struct dwo_file *dwo_file,
7118 VEC (dwarf2_section_info_def) *types,
7122 struct dwarf2_section_info *section;
7124 if (VEC_empty (dwarf2_section_info_def, types))
7128 VEC_iterate (dwarf2_section_info_def, types, ix, section);
7130 create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
7131 types_htab, rcuh_kind::TYPE);
7134 /* Create the hash table of all entries in the .debug_types section,
7135 and initialize all_type_units.
7136 The result is zero if there is an error (e.g. missing .debug_types section),
7137 otherwise non-zero. */
7140 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
7142 htab_t types_htab = NULL;
7143 struct signatured_type **iter;
7145 create_debug_type_hash_table (dwarf2_per_objfile, NULL,
7146 &dwarf2_per_objfile->info, types_htab,
7147 rcuh_kind::COMPILE);
7148 create_debug_types_hash_table (dwarf2_per_objfile, NULL,
7149 dwarf2_per_objfile->types, types_htab);
7150 if (types_htab == NULL)
7152 dwarf2_per_objfile->signatured_types = NULL;
7156 dwarf2_per_objfile->signatured_types = types_htab;
7158 dwarf2_per_objfile->n_type_units
7159 = dwarf2_per_objfile->n_allocated_type_units
7160 = htab_elements (types_htab);
7161 dwarf2_per_objfile->all_type_units =
7162 XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
7163 iter = &dwarf2_per_objfile->all_type_units[0];
7164 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
7165 gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
7166 == dwarf2_per_objfile->n_type_units);
7171 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
7172 If SLOT is non-NULL, it is the entry to use in the hash table.
7173 Otherwise we find one. */
7175 static struct signatured_type *
7176 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
7179 struct objfile *objfile = dwarf2_per_objfile->objfile;
7180 int n_type_units = dwarf2_per_objfile->n_type_units;
7181 struct signatured_type *sig_type;
7183 gdb_assert (n_type_units <= dwarf2_per_objfile->n_allocated_type_units);
7185 if (n_type_units > dwarf2_per_objfile->n_allocated_type_units)
7187 if (dwarf2_per_objfile->n_allocated_type_units == 0)
7188 dwarf2_per_objfile->n_allocated_type_units = 1;
7189 dwarf2_per_objfile->n_allocated_type_units *= 2;
7190 dwarf2_per_objfile->all_type_units
7191 = XRESIZEVEC (struct signatured_type *,
7192 dwarf2_per_objfile->all_type_units,
7193 dwarf2_per_objfile->n_allocated_type_units);
7194 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
7196 dwarf2_per_objfile->n_type_units = n_type_units;
7198 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7199 struct signatured_type);
7200 dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type;
7201 sig_type->signature = sig;
7202 sig_type->per_cu.is_debug_types = 1;
7203 if (dwarf2_per_objfile->using_index)
7205 sig_type->per_cu.v.quick =
7206 OBSTACK_ZALLOC (&objfile->objfile_obstack,
7207 struct dwarf2_per_cu_quick_data);
7212 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7215 gdb_assert (*slot == NULL);
7217 /* The rest of sig_type must be filled in by the caller. */
7221 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
7222 Fill in SIG_ENTRY with DWO_ENTRY. */
7225 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
7226 struct signatured_type *sig_entry,
7227 struct dwo_unit *dwo_entry)
7229 /* Make sure we're not clobbering something we don't expect to. */
7230 gdb_assert (! sig_entry->per_cu.queued);
7231 gdb_assert (sig_entry->per_cu.cu == NULL);
7232 if (dwarf2_per_objfile->using_index)
7234 gdb_assert (sig_entry->per_cu.v.quick != NULL);
7235 gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
7238 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
7239 gdb_assert (sig_entry->signature == dwo_entry->signature);
7240 gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
7241 gdb_assert (sig_entry->type_unit_group == NULL);
7242 gdb_assert (sig_entry->dwo_unit == NULL);
7244 sig_entry->per_cu.section = dwo_entry->section;
7245 sig_entry->per_cu.sect_off = dwo_entry->sect_off;
7246 sig_entry->per_cu.length = dwo_entry->length;
7247 sig_entry->per_cu.reading_dwo_directly = 1;
7248 sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
7249 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
7250 sig_entry->dwo_unit = dwo_entry;
7253 /* Subroutine of lookup_signatured_type.
7254 If we haven't read the TU yet, create the signatured_type data structure
7255 for a TU to be read in directly from a DWO file, bypassing the stub.
7256 This is the "Stay in DWO Optimization": When there is no DWP file and we're
7257 using .gdb_index, then when reading a CU we want to stay in the DWO file
7258 containing that CU. Otherwise we could end up reading several other DWO
7259 files (due to comdat folding) to process the transitive closure of all the
7260 mentioned TUs, and that can be slow. The current DWO file will have every
7261 type signature that it needs.
7262 We only do this for .gdb_index because in the psymtab case we already have
7263 to read all the DWOs to build the type unit groups. */
7265 static struct signatured_type *
7266 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7268 struct dwarf2_per_objfile *dwarf2_per_objfile
7269 = cu->per_cu->dwarf2_per_objfile;
7270 struct objfile *objfile = dwarf2_per_objfile->objfile;
7271 struct dwo_file *dwo_file;
7272 struct dwo_unit find_dwo_entry, *dwo_entry;
7273 struct signatured_type find_sig_entry, *sig_entry;
7276 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7278 /* If TU skeletons have been removed then we may not have read in any
7280 if (dwarf2_per_objfile->signatured_types == NULL)
7282 dwarf2_per_objfile->signatured_types
7283 = allocate_signatured_type_table (objfile);
7286 /* We only ever need to read in one copy of a signatured type.
7287 Use the global signatured_types array to do our own comdat-folding
7288 of types. If this is the first time we're reading this TU, and
7289 the TU has an entry in .gdb_index, replace the recorded data from
7290 .gdb_index with this TU. */
7292 find_sig_entry.signature = sig;
7293 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7294 &find_sig_entry, INSERT);
7295 sig_entry = (struct signatured_type *) *slot;
7297 /* We can get here with the TU already read, *or* in the process of being
7298 read. Don't reassign the global entry to point to this DWO if that's
7299 the case. Also note that if the TU is already being read, it may not
7300 have come from a DWO, the program may be a mix of Fission-compiled
7301 code and non-Fission-compiled code. */
7303 /* Have we already tried to read this TU?
7304 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7305 needn't exist in the global table yet). */
7306 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7309 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7310 dwo_unit of the TU itself. */
7311 dwo_file = cu->dwo_unit->dwo_file;
7313 /* Ok, this is the first time we're reading this TU. */
7314 if (dwo_file->tus == NULL)
7316 find_dwo_entry.signature = sig;
7317 dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7318 if (dwo_entry == NULL)
7321 /* If the global table doesn't have an entry for this TU, add one. */
7322 if (sig_entry == NULL)
7323 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7325 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7326 sig_entry->per_cu.tu_read = 1;
7330 /* Subroutine of lookup_signatured_type.
7331 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7332 then try the DWP file. If the TU stub (skeleton) has been removed then
7333 it won't be in .gdb_index. */
7335 static struct signatured_type *
7336 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7338 struct dwarf2_per_objfile *dwarf2_per_objfile
7339 = cu->per_cu->dwarf2_per_objfile;
7340 struct objfile *objfile = dwarf2_per_objfile->objfile;
7341 struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7342 struct dwo_unit *dwo_entry;
7343 struct signatured_type find_sig_entry, *sig_entry;
7346 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7347 gdb_assert (dwp_file != NULL);
7349 /* If TU skeletons have been removed then we may not have read in any
7351 if (dwarf2_per_objfile->signatured_types == NULL)
7353 dwarf2_per_objfile->signatured_types
7354 = allocate_signatured_type_table (objfile);
7357 find_sig_entry.signature = sig;
7358 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7359 &find_sig_entry, INSERT);
7360 sig_entry = (struct signatured_type *) *slot;
7362 /* Have we already tried to read this TU?
7363 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7364 needn't exist in the global table yet). */
7365 if (sig_entry != NULL)
7368 if (dwp_file->tus == NULL)
7370 dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7371 sig, 1 /* is_debug_types */);
7372 if (dwo_entry == NULL)
7375 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7376 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7381 /* Lookup a signature based type for DW_FORM_ref_sig8.
7382 Returns NULL if signature SIG is not present in the table.
7383 It is up to the caller to complain about this. */
7385 static struct signatured_type *
7386 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7388 struct dwarf2_per_objfile *dwarf2_per_objfile
7389 = cu->per_cu->dwarf2_per_objfile;
7392 && dwarf2_per_objfile->using_index)
7394 /* We're in a DWO/DWP file, and we're using .gdb_index.
7395 These cases require special processing. */
7396 if (get_dwp_file (dwarf2_per_objfile) == NULL)
7397 return lookup_dwo_signatured_type (cu, sig);
7399 return lookup_dwp_signatured_type (cu, sig);
7403 struct signatured_type find_entry, *entry;
7405 if (dwarf2_per_objfile->signatured_types == NULL)
7407 find_entry.signature = sig;
7408 entry = ((struct signatured_type *)
7409 htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7414 /* Low level DIE reading support. */
7416 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7419 init_cu_die_reader (struct die_reader_specs *reader,
7420 struct dwarf2_cu *cu,
7421 struct dwarf2_section_info *section,
7422 struct dwo_file *dwo_file)
7424 gdb_assert (section->readin && section->buffer != NULL);
7425 reader->abfd = get_section_bfd_owner (section);
7427 reader->dwo_file = dwo_file;
7428 reader->die_section = section;
7429 reader->buffer = section->buffer;
7430 reader->buffer_end = section->buffer + section->size;
7431 reader->comp_dir = NULL;
7434 /* Subroutine of init_cutu_and_read_dies to simplify it.
7435 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7436 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7439 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7440 from it to the DIE in the DWO. If NULL we are skipping the stub.
7441 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7442 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7443 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7444 STUB_COMP_DIR may be non-NULL.
7445 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7446 are filled in with the info of the DIE from the DWO file.
7447 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
7448 provided an abbrev table to use.
7449 The result is non-zero if a valid (non-dummy) DIE was found. */
7452 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7453 struct dwo_unit *dwo_unit,
7454 int abbrev_table_provided,
7455 struct die_info *stub_comp_unit_die,
7456 const char *stub_comp_dir,
7457 struct die_reader_specs *result_reader,
7458 const gdb_byte **result_info_ptr,
7459 struct die_info **result_comp_unit_die,
7460 int *result_has_children)
7462 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7463 struct objfile *objfile = dwarf2_per_objfile->objfile;
7464 struct dwarf2_cu *cu = this_cu->cu;
7465 struct dwarf2_section_info *section;
7467 const gdb_byte *begin_info_ptr, *info_ptr;
7468 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7469 int i,num_extra_attrs;
7470 struct dwarf2_section_info *dwo_abbrev_section;
7471 struct attribute *attr;
7472 struct die_info *comp_unit_die;
7474 /* At most one of these may be provided. */
7475 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7477 /* These attributes aren't processed until later:
7478 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7479 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7480 referenced later. However, these attributes are found in the stub
7481 which we won't have later. In order to not impose this complication
7482 on the rest of the code, we read them here and copy them to the
7491 if (stub_comp_unit_die != NULL)
7493 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7495 if (! this_cu->is_debug_types)
7496 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7497 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7498 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7499 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7500 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7502 /* There should be a DW_AT_addr_base attribute here (if needed).
7503 We need the value before we can process DW_FORM_GNU_addr_index. */
7505 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7507 cu->addr_base = DW_UNSND (attr);
7509 /* There should be a DW_AT_ranges_base attribute here (if needed).
7510 We need the value before we can process DW_AT_ranges. */
7511 cu->ranges_base = 0;
7512 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7514 cu->ranges_base = DW_UNSND (attr);
7516 else if (stub_comp_dir != NULL)
7518 /* Reconstruct the comp_dir attribute to simplify the code below. */
7519 comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7520 comp_dir->name = DW_AT_comp_dir;
7521 comp_dir->form = DW_FORM_string;
7522 DW_STRING_IS_CANONICAL (comp_dir) = 0;
7523 DW_STRING (comp_dir) = stub_comp_dir;
7526 /* Set up for reading the DWO CU/TU. */
7527 cu->dwo_unit = dwo_unit;
7528 section = dwo_unit->section;
7529 dwarf2_read_section (objfile, section);
7530 abfd = get_section_bfd_owner (section);
7531 begin_info_ptr = info_ptr = (section->buffer
7532 + to_underlying (dwo_unit->sect_off));
7533 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7534 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file);
7536 if (this_cu->is_debug_types)
7538 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7540 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7541 &cu->header, section,
7543 info_ptr, rcuh_kind::TYPE);
7544 /* This is not an assert because it can be caused by bad debug info. */
7545 if (sig_type->signature != cu->header.signature)
7547 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7548 " TU at offset 0x%x [in module %s]"),
7549 hex_string (sig_type->signature),
7550 hex_string (cu->header.signature),
7551 to_underlying (dwo_unit->sect_off),
7552 bfd_get_filename (abfd));
7554 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7555 /* For DWOs coming from DWP files, we don't know the CU length
7556 nor the type's offset in the TU until now. */
7557 dwo_unit->length = get_cu_length (&cu->header);
7558 dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7560 /* Establish the type offset that can be used to lookup the type.
7561 For DWO files, we don't know it until now. */
7562 sig_type->type_offset_in_section
7563 = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7567 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7568 &cu->header, section,
7570 info_ptr, rcuh_kind::COMPILE);
7571 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7572 /* For DWOs coming from DWP files, we don't know the CU length
7574 dwo_unit->length = get_cu_length (&cu->header);
7577 /* Replace the CU's original abbrev table with the DWO's.
7578 Reminder: We can't read the abbrev table until we've read the header. */
7579 if (abbrev_table_provided)
7581 /* Don't free the provided abbrev table, the caller of
7582 init_cutu_and_read_dies owns it. */
7583 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
7584 /* Ensure the DWO abbrev table gets freed. */
7585 make_cleanup (dwarf2_free_abbrev_table, cu);
7589 dwarf2_free_abbrev_table (cu);
7590 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
7591 /* Leave any existing abbrev table cleanup as is. */
7594 /* Read in the die, but leave space to copy over the attributes
7595 from the stub. This has the benefit of simplifying the rest of
7596 the code - all the work to maintain the illusion of a single
7597 DW_TAG_{compile,type}_unit DIE is done here. */
7598 num_extra_attrs = ((stmt_list != NULL)
7602 + (comp_dir != NULL));
7603 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7604 result_has_children, num_extra_attrs);
7606 /* Copy over the attributes from the stub to the DIE we just read in. */
7607 comp_unit_die = *result_comp_unit_die;
7608 i = comp_unit_die->num_attrs;
7609 if (stmt_list != NULL)
7610 comp_unit_die->attrs[i++] = *stmt_list;
7612 comp_unit_die->attrs[i++] = *low_pc;
7613 if (high_pc != NULL)
7614 comp_unit_die->attrs[i++] = *high_pc;
7616 comp_unit_die->attrs[i++] = *ranges;
7617 if (comp_dir != NULL)
7618 comp_unit_die->attrs[i++] = *comp_dir;
7619 comp_unit_die->num_attrs += num_extra_attrs;
7621 if (dwarf_die_debug)
7623 fprintf_unfiltered (gdb_stdlog,
7624 "Read die from %s@0x%x of %s:\n",
7625 get_section_name (section),
7626 (unsigned) (begin_info_ptr - section->buffer),
7627 bfd_get_filename (abfd));
7628 dump_die (comp_unit_die, dwarf_die_debug);
7631 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7632 TUs by skipping the stub and going directly to the entry in the DWO file.
7633 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7634 to get it via circuitous means. Blech. */
7635 if (comp_dir != NULL)
7636 result_reader->comp_dir = DW_STRING (comp_dir);
7638 /* Skip dummy compilation units. */
7639 if (info_ptr >= begin_info_ptr + dwo_unit->length
7640 || peek_abbrev_code (abfd, info_ptr) == 0)
7643 *result_info_ptr = info_ptr;
7647 /* Subroutine of init_cutu_and_read_dies to simplify it.
7648 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7649 Returns NULL if the specified DWO unit cannot be found. */
7651 static struct dwo_unit *
7652 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7653 struct die_info *comp_unit_die)
7655 struct dwarf2_cu *cu = this_cu->cu;
7657 struct dwo_unit *dwo_unit;
7658 const char *comp_dir, *dwo_name;
7660 gdb_assert (cu != NULL);
7662 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7663 dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7664 comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7666 if (this_cu->is_debug_types)
7668 struct signatured_type *sig_type;
7670 /* Since this_cu is the first member of struct signatured_type,
7671 we can go from a pointer to one to a pointer to the other. */
7672 sig_type = (struct signatured_type *) this_cu;
7673 signature = sig_type->signature;
7674 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7678 struct attribute *attr;
7680 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7682 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7684 dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7685 signature = DW_UNSND (attr);
7686 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7693 /* Subroutine of init_cutu_and_read_dies to simplify it.
7694 See it for a description of the parameters.
7695 Read a TU directly from a DWO file, bypassing the stub.
7697 Note: This function could be a little bit simpler if we shared cleanups
7698 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
7699 to do, so we keep this function self-contained. Or we could move this
7700 into our caller, but it's complex enough already. */
7703 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7704 int use_existing_cu, int keep,
7705 die_reader_func_ftype *die_reader_func,
7708 struct dwarf2_cu *cu;
7709 struct signatured_type *sig_type;
7710 struct cleanup *cleanups, *free_cu_cleanup = NULL;
7711 struct die_reader_specs reader;
7712 const gdb_byte *info_ptr;
7713 struct die_info *comp_unit_die;
7715 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7717 /* Verify we can do the following downcast, and that we have the
7719 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7720 sig_type = (struct signatured_type *) this_cu;
7721 gdb_assert (sig_type->dwo_unit != NULL);
7723 cleanups = make_cleanup (null_cleanup, NULL);
7725 if (use_existing_cu && this_cu->cu != NULL)
7727 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7729 /* There's no need to do the rereading_dwo_cu handling that
7730 init_cutu_and_read_dies does since we don't read the stub. */
7734 /* If !use_existing_cu, this_cu->cu must be NULL. */
7735 gdb_assert (this_cu->cu == NULL);
7736 cu = XNEW (struct dwarf2_cu);
7737 init_one_comp_unit (cu, this_cu);
7738 /* If an error occurs while loading, release our storage. */
7739 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
7742 /* A future optimization, if needed, would be to use an existing
7743 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7744 could share abbrev tables. */
7746 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7747 0 /* abbrev_table_provided */,
7748 NULL /* stub_comp_unit_die */,
7749 sig_type->dwo_unit->dwo_file->comp_dir,
7751 &comp_unit_die, &has_children) == 0)
7754 do_cleanups (cleanups);
7758 /* All the "real" work is done here. */
7759 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7761 /* This duplicates the code in init_cutu_and_read_dies,
7762 but the alternative is making the latter more complex.
7763 This function is only for the special case of using DWO files directly:
7764 no point in overly complicating the general case just to handle this. */
7765 if (free_cu_cleanup != NULL)
7769 /* We've successfully allocated this compilation unit. Let our
7770 caller clean it up when finished with it. */
7771 discard_cleanups (free_cu_cleanup);
7773 /* We can only discard free_cu_cleanup and all subsequent cleanups.
7774 So we have to manually free the abbrev table. */
7775 dwarf2_free_abbrev_table (cu);
7777 /* Link this CU into read_in_chain. */
7778 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7779 dwarf2_per_objfile->read_in_chain = this_cu;
7782 do_cleanups (free_cu_cleanup);
7785 do_cleanups (cleanups);
7788 /* Initialize a CU (or TU) and read its DIEs.
7789 If the CU defers to a DWO file, read the DWO file as well.
7791 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7792 Otherwise the table specified in the comp unit header is read in and used.
7793 This is an optimization for when we already have the abbrev table.
7795 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7796 Otherwise, a new CU is allocated with xmalloc.
7798 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7799 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7801 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7802 linker) then DIE_READER_FUNC will not get called. */
7805 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7806 struct abbrev_table *abbrev_table,
7807 int use_existing_cu, int keep,
7808 die_reader_func_ftype *die_reader_func,
7811 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7812 struct objfile *objfile = dwarf2_per_objfile->objfile;
7813 struct dwarf2_section_info *section = this_cu->section;
7814 bfd *abfd = get_section_bfd_owner (section);
7815 struct dwarf2_cu *cu;
7816 const gdb_byte *begin_info_ptr, *info_ptr;
7817 struct die_reader_specs reader;
7818 struct die_info *comp_unit_die;
7820 struct attribute *attr;
7821 struct cleanup *cleanups, *free_cu_cleanup = NULL;
7822 struct signatured_type *sig_type = NULL;
7823 struct dwarf2_section_info *abbrev_section;
7824 /* Non-zero if CU currently points to a DWO file and we need to
7825 reread it. When this happens we need to reread the skeleton die
7826 before we can reread the DWO file (this only applies to CUs, not TUs). */
7827 int rereading_dwo_cu = 0;
7829 if (dwarf_die_debug)
7830 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
7831 this_cu->is_debug_types ? "type" : "comp",
7832 to_underlying (this_cu->sect_off));
7834 if (use_existing_cu)
7837 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7838 file (instead of going through the stub), short-circuit all of this. */
7839 if (this_cu->reading_dwo_directly)
7841 /* Narrow down the scope of possibilities to have to understand. */
7842 gdb_assert (this_cu->is_debug_types);
7843 gdb_assert (abbrev_table == NULL);
7844 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7845 die_reader_func, data);
7849 cleanups = make_cleanup (null_cleanup, NULL);
7851 /* This is cheap if the section is already read in. */
7852 dwarf2_read_section (objfile, section);
7854 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7856 abbrev_section = get_abbrev_section_for_cu (this_cu);
7858 if (use_existing_cu && this_cu->cu != NULL)
7861 /* If this CU is from a DWO file we need to start over, we need to
7862 refetch the attributes from the skeleton CU.
7863 This could be optimized by retrieving those attributes from when we
7864 were here the first time: the previous comp_unit_die was stored in
7865 comp_unit_obstack. But there's no data yet that we need this
7867 if (cu->dwo_unit != NULL)
7868 rereading_dwo_cu = 1;
7872 /* If !use_existing_cu, this_cu->cu must be NULL. */
7873 gdb_assert (this_cu->cu == NULL);
7874 cu = XNEW (struct dwarf2_cu);
7875 init_one_comp_unit (cu, this_cu);
7876 /* If an error occurs while loading, release our storage. */
7877 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
7880 /* Get the header. */
7881 if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7883 /* We already have the header, there's no need to read it in again. */
7884 info_ptr += to_underlying (cu->header.first_die_cu_offset);
7888 if (this_cu->is_debug_types)
7890 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7891 &cu->header, section,
7892 abbrev_section, info_ptr,
7895 /* Since per_cu is the first member of struct signatured_type,
7896 we can go from a pointer to one to a pointer to the other. */
7897 sig_type = (struct signatured_type *) this_cu;
7898 gdb_assert (sig_type->signature == cu->header.signature);
7899 gdb_assert (sig_type->type_offset_in_tu
7900 == cu->header.type_cu_offset_in_tu);
7901 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7903 /* LENGTH has not been set yet for type units if we're
7904 using .gdb_index. */
7905 this_cu->length = get_cu_length (&cu->header);
7907 /* Establish the type offset that can be used to lookup the type. */
7908 sig_type->type_offset_in_section =
7909 this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7911 this_cu->dwarf_version = cu->header.version;
7915 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7916 &cu->header, section,
7919 rcuh_kind::COMPILE);
7921 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7922 gdb_assert (this_cu->length == get_cu_length (&cu->header));
7923 this_cu->dwarf_version = cu->header.version;
7927 /* Skip dummy compilation units. */
7928 if (info_ptr >= begin_info_ptr + this_cu->length
7929 || peek_abbrev_code (abfd, info_ptr) == 0)
7931 do_cleanups (cleanups);
7935 /* If we don't have them yet, read the abbrevs for this compilation unit.
7936 And if we need to read them now, make sure they're freed when we're
7937 done. Note that it's important that if the CU had an abbrev table
7938 on entry we don't free it when we're done: Somewhere up the call stack
7939 it may be in use. */
7940 if (abbrev_table != NULL)
7942 gdb_assert (cu->abbrev_table == NULL);
7943 gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7944 cu->abbrev_table = abbrev_table;
7946 else if (cu->abbrev_table == NULL)
7948 dwarf2_read_abbrevs (cu, abbrev_section);
7949 make_cleanup (dwarf2_free_abbrev_table, cu);
7951 else if (rereading_dwo_cu)
7953 dwarf2_free_abbrev_table (cu);
7954 dwarf2_read_abbrevs (cu, abbrev_section);
7957 /* Read the top level CU/TU die. */
7958 init_cu_die_reader (&reader, cu, section, NULL);
7959 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7961 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7963 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7964 DWO CU, that this test will fail (the attribute will not be present). */
7965 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7968 struct dwo_unit *dwo_unit;
7969 struct die_info *dwo_comp_unit_die;
7973 complaint (&symfile_complaints,
7974 _("compilation unit with DW_AT_GNU_dwo_name"
7975 " has children (offset 0x%x) [in module %s]"),
7976 to_underlying (this_cu->sect_off), bfd_get_filename (abfd));
7978 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7979 if (dwo_unit != NULL)
7981 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7982 abbrev_table != NULL,
7983 comp_unit_die, NULL,
7985 &dwo_comp_unit_die, &has_children) == 0)
7988 do_cleanups (cleanups);
7991 comp_unit_die = dwo_comp_unit_die;
7995 /* Yikes, we couldn't find the rest of the DIE, we only have
7996 the stub. A complaint has already been logged. There's
7997 not much more we can do except pass on the stub DIE to
7998 die_reader_func. We don't want to throw an error on bad
8003 /* All of the above is setup for this call. Yikes. */
8004 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
8006 /* Done, clean up. */
8007 if (free_cu_cleanup != NULL)
8011 /* We've successfully allocated this compilation unit. Let our
8012 caller clean it up when finished with it. */
8013 discard_cleanups (free_cu_cleanup);
8015 /* We can only discard free_cu_cleanup and all subsequent cleanups.
8016 So we have to manually free the abbrev table. */
8017 dwarf2_free_abbrev_table (cu);
8019 /* Link this CU into read_in_chain. */
8020 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
8021 dwarf2_per_objfile->read_in_chain = this_cu;
8024 do_cleanups (free_cu_cleanup);
8027 do_cleanups (cleanups);
8030 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
8031 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
8032 to have already done the lookup to find the DWO file).
8034 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
8035 THIS_CU->is_debug_types, but nothing else.
8037 We fill in THIS_CU->length.
8039 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
8040 linker) then DIE_READER_FUNC will not get called.
8042 THIS_CU->cu is always freed when done.
8043 This is done in order to not leave THIS_CU->cu in a state where we have
8044 to care whether it refers to the "main" CU or the DWO CU. */
8047 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
8048 struct dwo_file *dwo_file,
8049 die_reader_func_ftype *die_reader_func,
8052 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
8053 struct objfile *objfile = dwarf2_per_objfile->objfile;
8054 struct dwarf2_section_info *section = this_cu->section;
8055 bfd *abfd = get_section_bfd_owner (section);
8056 struct dwarf2_section_info *abbrev_section;
8057 struct dwarf2_cu cu;
8058 const gdb_byte *begin_info_ptr, *info_ptr;
8059 struct die_reader_specs reader;
8060 struct cleanup *cleanups;
8061 struct die_info *comp_unit_die;
8064 if (dwarf_die_debug)
8065 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
8066 this_cu->is_debug_types ? "type" : "comp",
8067 to_underlying (this_cu->sect_off));
8069 gdb_assert (this_cu->cu == NULL);
8071 abbrev_section = (dwo_file != NULL
8072 ? &dwo_file->sections.abbrev
8073 : get_abbrev_section_for_cu (this_cu));
8075 /* This is cheap if the section is already read in. */
8076 dwarf2_read_section (objfile, section);
8078 init_one_comp_unit (&cu, this_cu);
8080 cleanups = make_cleanup (free_stack_comp_unit, &cu);
8082 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
8083 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
8084 &cu.header, section,
8085 abbrev_section, info_ptr,
8086 (this_cu->is_debug_types
8088 : rcuh_kind::COMPILE));
8090 this_cu->length = get_cu_length (&cu.header);
8092 /* Skip dummy compilation units. */
8093 if (info_ptr >= begin_info_ptr + this_cu->length
8094 || peek_abbrev_code (abfd, info_ptr) == 0)
8096 do_cleanups (cleanups);
8100 dwarf2_read_abbrevs (&cu, abbrev_section);
8101 make_cleanup (dwarf2_free_abbrev_table, &cu);
8103 init_cu_die_reader (&reader, &cu, section, dwo_file);
8104 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
8106 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
8108 do_cleanups (cleanups);
8111 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
8112 does not lookup the specified DWO file.
8113 This cannot be used to read DWO files.
8115 THIS_CU->cu is always freed when done.
8116 This is done in order to not leave THIS_CU->cu in a state where we have
8117 to care whether it refers to the "main" CU or the DWO CU.
8118 We can revisit this if the data shows there's a performance issue. */
8121 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
8122 die_reader_func_ftype *die_reader_func,
8125 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
8128 /* Type Unit Groups.
8130 Type Unit Groups are a way to collapse the set of all TUs (type units) into
8131 a more manageable set. The grouping is done by DW_AT_stmt_list entry
8132 so that all types coming from the same compilation (.o file) are grouped
8133 together. A future step could be to put the types in the same symtab as
8134 the CU the types ultimately came from. */
8137 hash_type_unit_group (const void *item)
8139 const struct type_unit_group *tu_group
8140 = (const struct type_unit_group *) item;
8142 return hash_stmt_list_entry (&tu_group->hash);
8146 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
8148 const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
8149 const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
8151 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
8154 /* Allocate a hash table for type unit groups. */
8157 allocate_type_unit_groups_table (struct objfile *objfile)
8159 return htab_create_alloc_ex (3,
8160 hash_type_unit_group,
8163 &objfile->objfile_obstack,
8164 hashtab_obstack_allocate,
8165 dummy_obstack_deallocate);
8168 /* Type units that don't have DW_AT_stmt_list are grouped into their own
8169 partial symtabs. We combine several TUs per psymtab to not let the size
8170 of any one psymtab grow too big. */
8171 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
8172 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
8174 /* Helper routine for get_type_unit_group.
8175 Create the type_unit_group object used to hold one or more TUs. */
8177 static struct type_unit_group *
8178 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
8180 struct dwarf2_per_objfile *dwarf2_per_objfile
8181 = cu->per_cu->dwarf2_per_objfile;
8182 struct objfile *objfile = dwarf2_per_objfile->objfile;
8183 struct dwarf2_per_cu_data *per_cu;
8184 struct type_unit_group *tu_group;
8186 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
8187 struct type_unit_group);
8188 per_cu = &tu_group->per_cu;
8189 per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8191 if (dwarf2_per_objfile->using_index)
8193 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
8194 struct dwarf2_per_cu_quick_data);
8198 unsigned int line_offset = to_underlying (line_offset_struct);
8199 struct partial_symtab *pst;
8202 /* Give the symtab a useful name for debug purposes. */
8203 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
8204 name = xstrprintf ("<type_units_%d>",
8205 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
8207 name = xstrprintf ("<type_units_at_0x%x>", line_offset);
8209 pst = create_partial_symtab (per_cu, name);
8215 tu_group->hash.dwo_unit = cu->dwo_unit;
8216 tu_group->hash.line_sect_off = line_offset_struct;
8221 /* Look up the type_unit_group for type unit CU, and create it if necessary.
8222 STMT_LIST is a DW_AT_stmt_list attribute. */
8224 static struct type_unit_group *
8225 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
8227 struct dwarf2_per_objfile *dwarf2_per_objfile
8228 = cu->per_cu->dwarf2_per_objfile;
8229 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8230 struct type_unit_group *tu_group;
8232 unsigned int line_offset;
8233 struct type_unit_group type_unit_group_for_lookup;
8235 if (dwarf2_per_objfile->type_unit_groups == NULL)
8237 dwarf2_per_objfile->type_unit_groups =
8238 allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
8241 /* Do we need to create a new group, or can we use an existing one? */
8245 line_offset = DW_UNSND (stmt_list);
8246 ++tu_stats->nr_symtab_sharers;
8250 /* Ugh, no stmt_list. Rare, but we have to handle it.
8251 We can do various things here like create one group per TU or
8252 spread them over multiple groups to split up the expansion work.
8253 To avoid worst case scenarios (too many groups or too large groups)
8254 we, umm, group them in bunches. */
8255 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
8256 | (tu_stats->nr_stmt_less_type_units
8257 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
8258 ++tu_stats->nr_stmt_less_type_units;
8261 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
8262 type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
8263 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
8264 &type_unit_group_for_lookup, INSERT);
8267 tu_group = (struct type_unit_group *) *slot;
8268 gdb_assert (tu_group != NULL);
8272 sect_offset line_offset_struct = (sect_offset) line_offset;
8273 tu_group = create_type_unit_group (cu, line_offset_struct);
8275 ++tu_stats->nr_symtabs;
8281 /* Partial symbol tables. */
8283 /* Create a psymtab named NAME and assign it to PER_CU.
8285 The caller must fill in the following details:
8286 dirname, textlow, texthigh. */
8288 static struct partial_symtab *
8289 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
8291 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
8292 struct partial_symtab *pst;
8294 pst = start_psymtab_common (objfile, name, 0,
8295 objfile->global_psymbols,
8296 objfile->static_psymbols);
8298 pst->psymtabs_addrmap_supported = 1;
8300 /* This is the glue that links PST into GDB's symbol API. */
8301 pst->read_symtab_private = per_cu;
8302 pst->read_symtab = dwarf2_read_symtab;
8303 per_cu->v.psymtab = pst;
8308 /* The DATA object passed to process_psymtab_comp_unit_reader has this
8311 struct process_psymtab_comp_unit_data
8313 /* True if we are reading a DW_TAG_partial_unit. */
8315 int want_partial_unit;
8317 /* The "pretend" language that is used if the CU doesn't declare a
8320 enum language pretend_language;
8323 /* die_reader_func for process_psymtab_comp_unit. */
8326 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
8327 const gdb_byte *info_ptr,
8328 struct die_info *comp_unit_die,
8332 struct dwarf2_cu *cu = reader->cu;
8333 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
8334 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8335 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8337 CORE_ADDR best_lowpc = 0, best_highpc = 0;
8338 struct partial_symtab *pst;
8339 enum pc_bounds_kind cu_bounds_kind;
8340 const char *filename;
8341 struct process_psymtab_comp_unit_data *info
8342 = (struct process_psymtab_comp_unit_data *) data;
8344 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
8347 gdb_assert (! per_cu->is_debug_types);
8349 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
8351 cu->list_in_scope = &file_symbols;
8353 /* Allocate a new partial symbol table structure. */
8354 filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
8355 if (filename == NULL)
8358 pst = create_partial_symtab (per_cu, filename);
8360 /* This must be done before calling dwarf2_build_include_psymtabs. */
8361 pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
8363 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8365 dwarf2_find_base_address (comp_unit_die, cu);
8367 /* Possibly set the default values of LOWPC and HIGHPC from
8369 cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8370 &best_highpc, cu, pst);
8371 if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8372 /* Store the contiguous range if it is not empty; it can be empty for
8373 CUs with no code. */
8374 addrmap_set_empty (objfile->psymtabs_addrmap,
8375 gdbarch_adjust_dwarf2_addr (gdbarch,
8376 best_lowpc + baseaddr),
8377 gdbarch_adjust_dwarf2_addr (gdbarch,
8378 best_highpc + baseaddr) - 1,
8381 /* Check if comp unit has_children.
8382 If so, read the rest of the partial symbols from this comp unit.
8383 If not, there's no more debug_info for this comp unit. */
8386 struct partial_die_info *first_die;
8387 CORE_ADDR lowpc, highpc;
8389 lowpc = ((CORE_ADDR) -1);
8390 highpc = ((CORE_ADDR) 0);
8392 first_die = load_partial_dies (reader, info_ptr, 1);
8394 scan_partial_symbols (first_die, &lowpc, &highpc,
8395 cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8397 /* If we didn't find a lowpc, set it to highpc to avoid
8398 complaints from `maint check'. */
8399 if (lowpc == ((CORE_ADDR) -1))
8402 /* If the compilation unit didn't have an explicit address range,
8403 then use the information extracted from its child dies. */
8404 if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8407 best_highpc = highpc;
8410 pst->textlow = gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr);
8411 pst->texthigh = gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr);
8413 end_psymtab_common (objfile, pst);
8415 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8418 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8419 struct dwarf2_per_cu_data *iter;
8421 /* Fill in 'dependencies' here; we fill in 'users' in a
8423 pst->number_of_dependencies = len;
8425 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8427 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8430 pst->dependencies[i] = iter->v.psymtab;
8432 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8435 /* Get the list of files included in the current compilation unit,
8436 and build a psymtab for each of them. */
8437 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8439 if (dwarf_read_debug)
8441 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8443 fprintf_unfiltered (gdb_stdlog,
8444 "Psymtab for %s unit @0x%x: %s - %s"
8445 ", %d global, %d static syms\n",
8446 per_cu->is_debug_types ? "type" : "comp",
8447 to_underlying (per_cu->sect_off),
8448 paddress (gdbarch, pst->textlow),
8449 paddress (gdbarch, pst->texthigh),
8450 pst->n_global_syms, pst->n_static_syms);
8454 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8455 Process compilation unit THIS_CU for a psymtab. */
8458 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8459 int want_partial_unit,
8460 enum language pretend_language)
8462 /* If this compilation unit was already read in, free the
8463 cached copy in order to read it in again. This is
8464 necessary because we skipped some symbols when we first
8465 read in the compilation unit (see load_partial_dies).
8466 This problem could be avoided, but the benefit is unclear. */
8467 if (this_cu->cu != NULL)
8468 free_one_cached_comp_unit (this_cu);
8470 if (this_cu->is_debug_types)
8471 init_cutu_and_read_dies (this_cu, NULL, 0, 0, build_type_psymtabs_reader,
8475 process_psymtab_comp_unit_data info;
8476 info.want_partial_unit = want_partial_unit;
8477 info.pretend_language = pretend_language;
8478 init_cutu_and_read_dies (this_cu, NULL, 0, 0,
8479 process_psymtab_comp_unit_reader, &info);
8482 /* Age out any secondary CUs. */
8483 age_cached_comp_units (this_cu->dwarf2_per_objfile);
8486 /* Reader function for build_type_psymtabs. */
8489 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8490 const gdb_byte *info_ptr,
8491 struct die_info *type_unit_die,
8495 struct dwarf2_per_objfile *dwarf2_per_objfile
8496 = reader->cu->per_cu->dwarf2_per_objfile;
8497 struct objfile *objfile = dwarf2_per_objfile->objfile;
8498 struct dwarf2_cu *cu = reader->cu;
8499 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8500 struct signatured_type *sig_type;
8501 struct type_unit_group *tu_group;
8502 struct attribute *attr;
8503 struct partial_die_info *first_die;
8504 CORE_ADDR lowpc, highpc;
8505 struct partial_symtab *pst;
8507 gdb_assert (data == NULL);
8508 gdb_assert (per_cu->is_debug_types);
8509 sig_type = (struct signatured_type *) per_cu;
8514 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8515 tu_group = get_type_unit_group (cu, attr);
8517 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8519 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8520 cu->list_in_scope = &file_symbols;
8521 pst = create_partial_symtab (per_cu, "");
8524 first_die = load_partial_dies (reader, info_ptr, 1);
8526 lowpc = (CORE_ADDR) -1;
8527 highpc = (CORE_ADDR) 0;
8528 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8530 end_psymtab_common (objfile, pst);
8533 /* Struct used to sort TUs by their abbreviation table offset. */
8535 struct tu_abbrev_offset
8537 struct signatured_type *sig_type;
8538 sect_offset abbrev_offset;
8541 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
8544 sort_tu_by_abbrev_offset (const void *ap, const void *bp)
8546 const struct tu_abbrev_offset * const *a
8547 = (const struct tu_abbrev_offset * const*) ap;
8548 const struct tu_abbrev_offset * const *b
8549 = (const struct tu_abbrev_offset * const*) bp;
8550 sect_offset aoff = (*a)->abbrev_offset;
8551 sect_offset boff = (*b)->abbrev_offset;
8553 return (aoff > boff) - (aoff < boff);
8556 /* Efficiently read all the type units.
8557 This does the bulk of the work for build_type_psymtabs.
8559 The efficiency is because we sort TUs by the abbrev table they use and
8560 only read each abbrev table once. In one program there are 200K TUs
8561 sharing 8K abbrev tables.
8563 The main purpose of this function is to support building the
8564 dwarf2_per_objfile->type_unit_groups table.
8565 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8566 can collapse the search space by grouping them by stmt_list.
8567 The savings can be significant, in the same program from above the 200K TUs
8568 share 8K stmt_list tables.
8570 FUNC is expected to call get_type_unit_group, which will create the
8571 struct type_unit_group if necessary and add it to
8572 dwarf2_per_objfile->type_unit_groups. */
8575 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8577 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8578 struct cleanup *cleanups;
8579 struct abbrev_table *abbrev_table;
8580 sect_offset abbrev_offset;
8581 struct tu_abbrev_offset *sorted_by_abbrev;
8584 /* It's up to the caller to not call us multiple times. */
8585 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8587 if (dwarf2_per_objfile->n_type_units == 0)
8590 /* TUs typically share abbrev tables, and there can be way more TUs than
8591 abbrev tables. Sort by abbrev table to reduce the number of times we
8592 read each abbrev table in.
8593 Alternatives are to punt or to maintain a cache of abbrev tables.
8594 This is simpler and efficient enough for now.
8596 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8597 symtab to use). Typically TUs with the same abbrev offset have the same
8598 stmt_list value too so in practice this should work well.
8600 The basic algorithm here is:
8602 sort TUs by abbrev table
8603 for each TU with same abbrev table:
8604 read abbrev table if first user
8605 read TU top level DIE
8606 [IWBN if DWO skeletons had DW_AT_stmt_list]
8609 if (dwarf_read_debug)
8610 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8612 /* Sort in a separate table to maintain the order of all_type_units
8613 for .gdb_index: TU indices directly index all_type_units. */
8614 sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset,
8615 dwarf2_per_objfile->n_type_units);
8616 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
8618 struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
8620 sorted_by_abbrev[i].sig_type = sig_type;
8621 sorted_by_abbrev[i].abbrev_offset =
8622 read_abbrev_offset (dwarf2_per_objfile,
8623 sig_type->per_cu.section,
8624 sig_type->per_cu.sect_off);
8626 cleanups = make_cleanup (xfree, sorted_by_abbrev);
8627 qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units,
8628 sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset);
8630 abbrev_offset = (sect_offset) ~(unsigned) 0;
8631 abbrev_table = NULL;
8632 make_cleanup (abbrev_table_free_cleanup, &abbrev_table);
8634 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
8636 const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
8638 /* Switch to the next abbrev table if necessary. */
8639 if (abbrev_table == NULL
8640 || tu->abbrev_offset != abbrev_offset)
8642 if (abbrev_table != NULL)
8644 abbrev_table_free (abbrev_table);
8645 /* Reset to NULL in case abbrev_table_read_table throws
8646 an error: abbrev_table_free_cleanup will get called. */
8647 abbrev_table = NULL;
8649 abbrev_offset = tu->abbrev_offset;
8651 abbrev_table_read_table (dwarf2_per_objfile,
8652 &dwarf2_per_objfile->abbrev,
8654 ++tu_stats->nr_uniq_abbrev_tables;
8657 init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0,
8658 build_type_psymtabs_reader, NULL);
8661 do_cleanups (cleanups);
8664 /* Print collected type unit statistics. */
8667 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8669 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8671 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8672 fprintf_unfiltered (gdb_stdlog, " %d TUs\n",
8673 dwarf2_per_objfile->n_type_units);
8674 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
8675 tu_stats->nr_uniq_abbrev_tables);
8676 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
8677 tu_stats->nr_symtabs);
8678 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
8679 tu_stats->nr_symtab_sharers);
8680 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
8681 tu_stats->nr_stmt_less_type_units);
8682 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
8683 tu_stats->nr_all_type_units_reallocs);
8686 /* Traversal function for build_type_psymtabs. */
8689 build_type_psymtab_dependencies (void **slot, void *info)
8691 struct dwarf2_per_objfile *dwarf2_per_objfile
8692 = (struct dwarf2_per_objfile *) info;
8693 struct objfile *objfile = dwarf2_per_objfile->objfile;
8694 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8695 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8696 struct partial_symtab *pst = per_cu->v.psymtab;
8697 int len = VEC_length (sig_type_ptr, tu_group->tus);
8698 struct signatured_type *iter;
8701 gdb_assert (len > 0);
8702 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8704 pst->number_of_dependencies = len;
8706 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8708 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8711 gdb_assert (iter->per_cu.is_debug_types);
8712 pst->dependencies[i] = iter->per_cu.v.psymtab;
8713 iter->type_unit_group = tu_group;
8716 VEC_free (sig_type_ptr, tu_group->tus);
8721 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8722 Build partial symbol tables for the .debug_types comp-units. */
8725 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8727 if (! create_all_type_units (dwarf2_per_objfile))
8730 build_type_psymtabs_1 (dwarf2_per_objfile);
8733 /* Traversal function for process_skeletonless_type_unit.
8734 Read a TU in a DWO file and build partial symbols for it. */
8737 process_skeletonless_type_unit (void **slot, void *info)
8739 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8740 struct dwarf2_per_objfile *dwarf2_per_objfile
8741 = (struct dwarf2_per_objfile *) info;
8742 struct signatured_type find_entry, *entry;
8744 /* If this TU doesn't exist in the global table, add it and read it in. */
8746 if (dwarf2_per_objfile->signatured_types == NULL)
8748 dwarf2_per_objfile->signatured_types
8749 = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8752 find_entry.signature = dwo_unit->signature;
8753 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8755 /* If we've already seen this type there's nothing to do. What's happening
8756 is we're doing our own version of comdat-folding here. */
8760 /* This does the job that create_all_type_units would have done for
8762 entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8763 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8766 /* This does the job that build_type_psymtabs_1 would have done. */
8767 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0,
8768 build_type_psymtabs_reader, NULL);
8773 /* Traversal function for process_skeletonless_type_units. */
8776 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8778 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8780 if (dwo_file->tus != NULL)
8782 htab_traverse_noresize (dwo_file->tus,
8783 process_skeletonless_type_unit, info);
8789 /* Scan all TUs of DWO files, verifying we've processed them.
8790 This is needed in case a TU was emitted without its skeleton.
8791 Note: This can't be done until we know what all the DWO files are. */
8794 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8796 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8797 if (get_dwp_file (dwarf2_per_objfile) == NULL
8798 && dwarf2_per_objfile->dwo_files != NULL)
8800 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8801 process_dwo_file_for_skeletonless_type_units,
8802 dwarf2_per_objfile);
8806 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8809 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8813 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
8815 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
8816 struct partial_symtab *pst = per_cu->v.psymtab;
8822 for (j = 0; j < pst->number_of_dependencies; ++j)
8824 /* Set the 'user' field only if it is not already set. */
8825 if (pst->dependencies[j]->user == NULL)
8826 pst->dependencies[j]->user = pst;
8831 /* Build the partial symbol table by doing a quick pass through the
8832 .debug_info and .debug_abbrev sections. */
8835 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8837 struct cleanup *back_to;
8839 struct objfile *objfile = dwarf2_per_objfile->objfile;
8841 if (dwarf_read_debug)
8843 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8844 objfile_name (objfile));
8847 dwarf2_per_objfile->reading_partial_symbols = 1;
8849 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8851 /* Any cached compilation units will be linked by the per-objfile
8852 read_in_chain. Make sure to free them when we're done. */
8853 back_to = make_cleanup (free_cached_comp_units, dwarf2_per_objfile);
8855 build_type_psymtabs (dwarf2_per_objfile);
8857 create_all_comp_units (dwarf2_per_objfile);
8859 /* Create a temporary address map on a temporary obstack. We later
8860 copy this to the final obstack. */
8861 auto_obstack temp_obstack;
8863 scoped_restore save_psymtabs_addrmap
8864 = make_scoped_restore (&objfile->psymtabs_addrmap,
8865 addrmap_create_mutable (&temp_obstack));
8867 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
8869 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
8871 process_psymtab_comp_unit (per_cu, 0, language_minimal);
8874 /* This has to wait until we read the CUs, we need the list of DWOs. */
8875 process_skeletonless_type_units (dwarf2_per_objfile);
8877 /* Now that all TUs have been processed we can fill in the dependencies. */
8878 if (dwarf2_per_objfile->type_unit_groups != NULL)
8880 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8881 build_type_psymtab_dependencies, dwarf2_per_objfile);
8884 if (dwarf_read_debug)
8885 print_tu_stats (dwarf2_per_objfile);
8887 set_partial_user (dwarf2_per_objfile);
8889 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
8890 &objfile->objfile_obstack);
8891 /* At this point we want to keep the address map. */
8892 save_psymtabs_addrmap.release ();
8894 do_cleanups (back_to);
8896 if (dwarf_read_debug)
8897 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8898 objfile_name (objfile));
8901 /* die_reader_func for load_partial_comp_unit. */
8904 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8905 const gdb_byte *info_ptr,
8906 struct die_info *comp_unit_die,
8910 struct dwarf2_cu *cu = reader->cu;
8912 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8914 /* Check if comp unit has_children.
8915 If so, read the rest of the partial symbols from this comp unit.
8916 If not, there's no more debug_info for this comp unit. */
8918 load_partial_dies (reader, info_ptr, 0);
8921 /* Load the partial DIEs for a secondary CU into memory.
8922 This is also used when rereading a primary CU with load_all_dies. */
8925 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8927 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
8928 load_partial_comp_unit_reader, NULL);
8932 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8933 struct dwarf2_section_info *section,
8934 struct dwarf2_section_info *abbrev_section,
8935 unsigned int is_dwz,
8938 struct dwarf2_per_cu_data ***all_comp_units)
8940 const gdb_byte *info_ptr;
8941 struct objfile *objfile = dwarf2_per_objfile->objfile;
8943 if (dwarf_read_debug)
8944 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8945 get_section_name (section),
8946 get_section_file_name (section));
8948 dwarf2_read_section (objfile, section);
8950 info_ptr = section->buffer;
8952 while (info_ptr < section->buffer + section->size)
8954 struct dwarf2_per_cu_data *this_cu;
8956 sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8958 comp_unit_head cu_header;
8959 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8960 abbrev_section, info_ptr,
8961 rcuh_kind::COMPILE);
8963 /* Save the compilation unit for later lookup. */
8964 if (cu_header.unit_type != DW_UT_type)
8966 this_cu = XOBNEW (&objfile->objfile_obstack,
8967 struct dwarf2_per_cu_data);
8968 memset (this_cu, 0, sizeof (*this_cu));
8972 auto sig_type = XOBNEW (&objfile->objfile_obstack,
8973 struct signatured_type);
8974 memset (sig_type, 0, sizeof (*sig_type));
8975 sig_type->signature = cu_header.signature;
8976 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8977 this_cu = &sig_type->per_cu;
8979 this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8980 this_cu->sect_off = sect_off;
8981 this_cu->length = cu_header.length + cu_header.initial_length_size;
8982 this_cu->is_dwz = is_dwz;
8983 this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8984 this_cu->section = section;
8986 if (*n_comp_units == *n_allocated)
8989 *all_comp_units = XRESIZEVEC (struct dwarf2_per_cu_data *,
8990 *all_comp_units, *n_allocated);
8992 (*all_comp_units)[*n_comp_units] = this_cu;
8995 info_ptr = info_ptr + this_cu->length;
8999 /* Create a list of all compilation units in OBJFILE.
9000 This is only done for -readnow and building partial symtabs. */
9003 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
9007 struct dwarf2_per_cu_data **all_comp_units;
9008 struct dwz_file *dwz;
9009 struct objfile *objfile = dwarf2_per_objfile->objfile;
9013 all_comp_units = XNEWVEC (struct dwarf2_per_cu_data *, n_allocated);
9015 read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
9016 &dwarf2_per_objfile->abbrev, 0,
9017 &n_allocated, &n_comp_units, &all_comp_units);
9019 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
9021 read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
9022 1, &n_allocated, &n_comp_units,
9025 dwarf2_per_objfile->all_comp_units = XOBNEWVEC (&objfile->objfile_obstack,
9026 struct dwarf2_per_cu_data *,
9028 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
9029 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
9030 xfree (all_comp_units);
9031 dwarf2_per_objfile->n_comp_units = n_comp_units;
9034 /* Process all loaded DIEs for compilation unit CU, starting at
9035 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
9036 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
9037 DW_AT_ranges). See the comments of add_partial_subprogram on how
9038 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
9041 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
9042 CORE_ADDR *highpc, int set_addrmap,
9043 struct dwarf2_cu *cu)
9045 struct partial_die_info *pdi;
9047 /* Now, march along the PDI's, descending into ones which have
9048 interesting children but skipping the children of the other ones,
9049 until we reach the end of the compilation unit. */
9055 fixup_partial_die (pdi, cu);
9057 /* Anonymous namespaces or modules have no name but have interesting
9058 children, so we need to look at them. Ditto for anonymous
9061 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
9062 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
9063 || pdi->tag == DW_TAG_imported_unit
9064 || pdi->tag == DW_TAG_inlined_subroutine)
9068 case DW_TAG_subprogram:
9069 case DW_TAG_inlined_subroutine:
9070 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9072 case DW_TAG_constant:
9073 case DW_TAG_variable:
9074 case DW_TAG_typedef:
9075 case DW_TAG_union_type:
9076 if (!pdi->is_declaration)
9078 add_partial_symbol (pdi, cu);
9081 case DW_TAG_class_type:
9082 case DW_TAG_interface_type:
9083 case DW_TAG_structure_type:
9084 if (!pdi->is_declaration)
9086 add_partial_symbol (pdi, cu);
9088 if (cu->language == language_rust && pdi->has_children)
9089 scan_partial_symbols (pdi->die_child, lowpc, highpc,
9092 case DW_TAG_enumeration_type:
9093 if (!pdi->is_declaration)
9094 add_partial_enumeration (pdi, cu);
9096 case DW_TAG_base_type:
9097 case DW_TAG_subrange_type:
9098 /* File scope base type definitions are added to the partial
9100 add_partial_symbol (pdi, cu);
9102 case DW_TAG_namespace:
9103 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
9106 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
9108 case DW_TAG_imported_unit:
9110 struct dwarf2_per_cu_data *per_cu;
9112 /* For now we don't handle imported units in type units. */
9113 if (cu->per_cu->is_debug_types)
9115 error (_("Dwarf Error: DW_TAG_imported_unit is not"
9116 " supported in type units [in module %s]"),
9117 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
9120 per_cu = dwarf2_find_containing_comp_unit
9121 (pdi->d.sect_off, pdi->is_dwz,
9122 cu->per_cu->dwarf2_per_objfile);
9124 /* Go read the partial unit, if needed. */
9125 if (per_cu->v.psymtab == NULL)
9126 process_psymtab_comp_unit (per_cu, 1, cu->language);
9128 VEC_safe_push (dwarf2_per_cu_ptr,
9129 cu->per_cu->imported_symtabs, per_cu);
9132 case DW_TAG_imported_declaration:
9133 add_partial_symbol (pdi, cu);
9140 /* If the die has a sibling, skip to the sibling. */
9142 pdi = pdi->die_sibling;
9146 /* Functions used to compute the fully scoped name of a partial DIE.
9148 Normally, this is simple. For C++, the parent DIE's fully scoped
9149 name is concatenated with "::" and the partial DIE's name.
9150 Enumerators are an exception; they use the scope of their parent
9151 enumeration type, i.e. the name of the enumeration type is not
9152 prepended to the enumerator.
9154 There are two complexities. One is DW_AT_specification; in this
9155 case "parent" means the parent of the target of the specification,
9156 instead of the direct parent of the DIE. The other is compilers
9157 which do not emit DW_TAG_namespace; in this case we try to guess
9158 the fully qualified name of structure types from their members'
9159 linkage names. This must be done using the DIE's children rather
9160 than the children of any DW_AT_specification target. We only need
9161 to do this for structures at the top level, i.e. if the target of
9162 any DW_AT_specification (if any; otherwise the DIE itself) does not
9165 /* Compute the scope prefix associated with PDI's parent, in
9166 compilation unit CU. The result will be allocated on CU's
9167 comp_unit_obstack, or a copy of the already allocated PDI->NAME
9168 field. NULL is returned if no prefix is necessary. */
9170 partial_die_parent_scope (struct partial_die_info *pdi,
9171 struct dwarf2_cu *cu)
9173 const char *grandparent_scope;
9174 struct partial_die_info *parent, *real_pdi;
9176 /* We need to look at our parent DIE; if we have a DW_AT_specification,
9177 then this means the parent of the specification DIE. */
9180 while (real_pdi->has_specification)
9181 real_pdi = find_partial_die (real_pdi->spec_offset,
9182 real_pdi->spec_is_dwz, cu);
9184 parent = real_pdi->die_parent;
9188 if (parent->scope_set)
9189 return parent->scope;
9191 fixup_partial_die (parent, cu);
9193 grandparent_scope = partial_die_parent_scope (parent, cu);
9195 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
9196 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
9197 Work around this problem here. */
9198 if (cu->language == language_cplus
9199 && parent->tag == DW_TAG_namespace
9200 && strcmp (parent->name, "::") == 0
9201 && grandparent_scope == NULL)
9203 parent->scope = NULL;
9204 parent->scope_set = 1;
9208 if (pdi->tag == DW_TAG_enumerator)
9209 /* Enumerators should not get the name of the enumeration as a prefix. */
9210 parent->scope = grandparent_scope;
9211 else if (parent->tag == DW_TAG_namespace
9212 || parent->tag == DW_TAG_module
9213 || parent->tag == DW_TAG_structure_type
9214 || parent->tag == DW_TAG_class_type
9215 || parent->tag == DW_TAG_interface_type
9216 || parent->tag == DW_TAG_union_type
9217 || parent->tag == DW_TAG_enumeration_type)
9219 if (grandparent_scope == NULL)
9220 parent->scope = parent->name;
9222 parent->scope = typename_concat (&cu->comp_unit_obstack,
9224 parent->name, 0, cu);
9228 /* FIXME drow/2004-04-01: What should we be doing with
9229 function-local names? For partial symbols, we should probably be
9231 complaint (&symfile_complaints,
9232 _("unhandled containing DIE tag %d for DIE at %d"),
9233 parent->tag, to_underlying (pdi->sect_off));
9234 parent->scope = grandparent_scope;
9237 parent->scope_set = 1;
9238 return parent->scope;
9241 /* Return the fully scoped name associated with PDI, from compilation unit
9242 CU. The result will be allocated with malloc. */
9245 partial_die_full_name (struct partial_die_info *pdi,
9246 struct dwarf2_cu *cu)
9248 const char *parent_scope;
9250 /* If this is a template instantiation, we can not work out the
9251 template arguments from partial DIEs. So, unfortunately, we have
9252 to go through the full DIEs. At least any work we do building
9253 types here will be reused if full symbols are loaded later. */
9254 if (pdi->has_template_arguments)
9256 fixup_partial_die (pdi, cu);
9258 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
9260 struct die_info *die;
9261 struct attribute attr;
9262 struct dwarf2_cu *ref_cu = cu;
9264 /* DW_FORM_ref_addr is using section offset. */
9265 attr.name = (enum dwarf_attribute) 0;
9266 attr.form = DW_FORM_ref_addr;
9267 attr.u.unsnd = to_underlying (pdi->sect_off);
9268 die = follow_die_ref (NULL, &attr, &ref_cu);
9270 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
9274 parent_scope = partial_die_parent_scope (pdi, cu);
9275 if (parent_scope == NULL)
9278 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
9282 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
9284 struct dwarf2_per_objfile *dwarf2_per_objfile
9285 = cu->per_cu->dwarf2_per_objfile;
9286 struct objfile *objfile = dwarf2_per_objfile->objfile;
9287 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9289 const char *actual_name = NULL;
9291 char *built_actual_name;
9293 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
9295 built_actual_name = partial_die_full_name (pdi, cu);
9296 if (built_actual_name != NULL)
9297 actual_name = built_actual_name;
9299 if (actual_name == NULL)
9300 actual_name = pdi->name;
9304 case DW_TAG_inlined_subroutine:
9305 case DW_TAG_subprogram:
9306 addr = gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr);
9307 if (pdi->is_external || cu->language == language_ada)
9309 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
9310 of the global scope. But in Ada, we want to be able to access
9311 nested procedures globally. So all Ada subprograms are stored
9312 in the global scope. */
9313 add_psymbol_to_list (actual_name, strlen (actual_name),
9314 built_actual_name != NULL,
9315 VAR_DOMAIN, LOC_BLOCK,
9316 &objfile->global_psymbols,
9317 addr, cu->language, objfile);
9321 add_psymbol_to_list (actual_name, strlen (actual_name),
9322 built_actual_name != NULL,
9323 VAR_DOMAIN, LOC_BLOCK,
9324 &objfile->static_psymbols,
9325 addr, cu->language, objfile);
9328 if (pdi->main_subprogram && actual_name != NULL)
9329 set_objfile_main_name (objfile, actual_name, cu->language);
9331 case DW_TAG_constant:
9333 std::vector<partial_symbol *> *list;
9335 if (pdi->is_external)
9336 list = &objfile->global_psymbols;
9338 list = &objfile->static_psymbols;
9339 add_psymbol_to_list (actual_name, strlen (actual_name),
9340 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
9341 list, 0, cu->language, objfile);
9344 case DW_TAG_variable:
9346 addr = decode_locdesc (pdi->d.locdesc, cu);
9350 && !dwarf2_per_objfile->has_section_at_zero)
9352 /* A global or static variable may also have been stripped
9353 out by the linker if unused, in which case its address
9354 will be nullified; do not add such variables into partial
9355 symbol table then. */
9357 else if (pdi->is_external)
9360 Don't enter into the minimal symbol tables as there is
9361 a minimal symbol table entry from the ELF symbols already.
9362 Enter into partial symbol table if it has a location
9363 descriptor or a type.
9364 If the location descriptor is missing, new_symbol will create
9365 a LOC_UNRESOLVED symbol, the address of the variable will then
9366 be determined from the minimal symbol table whenever the variable
9368 The address for the partial symbol table entry is not
9369 used by GDB, but it comes in handy for debugging partial symbol
9372 if (pdi->d.locdesc || pdi->has_type)
9373 add_psymbol_to_list (actual_name, strlen (actual_name),
9374 built_actual_name != NULL,
9375 VAR_DOMAIN, LOC_STATIC,
9376 &objfile->global_psymbols,
9378 cu->language, objfile);
9382 int has_loc = pdi->d.locdesc != NULL;
9384 /* Static Variable. Skip symbols whose value we cannot know (those
9385 without location descriptors or constant values). */
9386 if (!has_loc && !pdi->has_const_value)
9388 xfree (built_actual_name);
9392 add_psymbol_to_list (actual_name, strlen (actual_name),
9393 built_actual_name != NULL,
9394 VAR_DOMAIN, LOC_STATIC,
9395 &objfile->static_psymbols,
9396 has_loc ? addr + baseaddr : (CORE_ADDR) 0,
9397 cu->language, objfile);
9400 case DW_TAG_typedef:
9401 case DW_TAG_base_type:
9402 case DW_TAG_subrange_type:
9403 add_psymbol_to_list (actual_name, strlen (actual_name),
9404 built_actual_name != NULL,
9405 VAR_DOMAIN, LOC_TYPEDEF,
9406 &objfile->static_psymbols,
9407 0, cu->language, objfile);
9409 case DW_TAG_imported_declaration:
9410 case DW_TAG_namespace:
9411 add_psymbol_to_list (actual_name, strlen (actual_name),
9412 built_actual_name != NULL,
9413 VAR_DOMAIN, LOC_TYPEDEF,
9414 &objfile->global_psymbols,
9415 0, cu->language, objfile);
9418 add_psymbol_to_list (actual_name, strlen (actual_name),
9419 built_actual_name != NULL,
9420 MODULE_DOMAIN, LOC_TYPEDEF,
9421 &objfile->global_psymbols,
9422 0, cu->language, objfile);
9424 case DW_TAG_class_type:
9425 case DW_TAG_interface_type:
9426 case DW_TAG_structure_type:
9427 case DW_TAG_union_type:
9428 case DW_TAG_enumeration_type:
9429 /* Skip external references. The DWARF standard says in the section
9430 about "Structure, Union, and Class Type Entries": "An incomplete
9431 structure, union or class type is represented by a structure,
9432 union or class entry that does not have a byte size attribute
9433 and that has a DW_AT_declaration attribute." */
9434 if (!pdi->has_byte_size && pdi->is_declaration)
9436 xfree (built_actual_name);
9440 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9441 static vs. global. */
9442 add_psymbol_to_list (actual_name, strlen (actual_name),
9443 built_actual_name != NULL,
9444 STRUCT_DOMAIN, LOC_TYPEDEF,
9445 cu->language == language_cplus
9446 ? &objfile->global_psymbols
9447 : &objfile->static_psymbols,
9448 0, cu->language, objfile);
9451 case DW_TAG_enumerator:
9452 add_psymbol_to_list (actual_name, strlen (actual_name),
9453 built_actual_name != NULL,
9454 VAR_DOMAIN, LOC_CONST,
9455 cu->language == language_cplus
9456 ? &objfile->global_psymbols
9457 : &objfile->static_psymbols,
9458 0, cu->language, objfile);
9464 xfree (built_actual_name);
9467 /* Read a partial die corresponding to a namespace; also, add a symbol
9468 corresponding to that namespace to the symbol table. NAMESPACE is
9469 the name of the enclosing namespace. */
9472 add_partial_namespace (struct partial_die_info *pdi,
9473 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9474 int set_addrmap, struct dwarf2_cu *cu)
9476 /* Add a symbol for the namespace. */
9478 add_partial_symbol (pdi, cu);
9480 /* Now scan partial symbols in that namespace. */
9482 if (pdi->has_children)
9483 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9486 /* Read a partial die corresponding to a Fortran module. */
9489 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9490 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9492 /* Add a symbol for the namespace. */
9494 add_partial_symbol (pdi, cu);
9496 /* Now scan partial symbols in that module. */
9498 if (pdi->has_children)
9499 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9502 /* Read a partial die corresponding to a subprogram or an inlined
9503 subprogram and create a partial symbol for that subprogram.
9504 When the CU language allows it, this routine also defines a partial
9505 symbol for each nested subprogram that this subprogram contains.
9506 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9507 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9509 PDI may also be a lexical block, in which case we simply search
9510 recursively for subprograms defined inside that lexical block.
9511 Again, this is only performed when the CU language allows this
9512 type of definitions. */
9515 add_partial_subprogram (struct partial_die_info *pdi,
9516 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9517 int set_addrmap, struct dwarf2_cu *cu)
9519 if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9521 if (pdi->has_pc_info)
9523 if (pdi->lowpc < *lowpc)
9524 *lowpc = pdi->lowpc;
9525 if (pdi->highpc > *highpc)
9526 *highpc = pdi->highpc;
9529 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9530 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9535 baseaddr = ANOFFSET (objfile->section_offsets,
9536 SECT_OFF_TEXT (objfile));
9537 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch,
9538 pdi->lowpc + baseaddr);
9539 highpc = gdbarch_adjust_dwarf2_addr (gdbarch,
9540 pdi->highpc + baseaddr);
9541 addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
9542 cu->per_cu->v.psymtab);
9546 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9548 if (!pdi->is_declaration)
9549 /* Ignore subprogram DIEs that do not have a name, they are
9550 illegal. Do not emit a complaint at this point, we will
9551 do so when we convert this psymtab into a symtab. */
9553 add_partial_symbol (pdi, cu);
9557 if (! pdi->has_children)
9560 if (cu->language == language_ada)
9562 pdi = pdi->die_child;
9565 fixup_partial_die (pdi, cu);
9566 if (pdi->tag == DW_TAG_subprogram
9567 || pdi->tag == DW_TAG_inlined_subroutine
9568 || pdi->tag == DW_TAG_lexical_block)
9569 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9570 pdi = pdi->die_sibling;
9575 /* Read a partial die corresponding to an enumeration type. */
9578 add_partial_enumeration (struct partial_die_info *enum_pdi,
9579 struct dwarf2_cu *cu)
9581 struct partial_die_info *pdi;
9583 if (enum_pdi->name != NULL)
9584 add_partial_symbol (enum_pdi, cu);
9586 pdi = enum_pdi->die_child;
9589 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9590 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
9592 add_partial_symbol (pdi, cu);
9593 pdi = pdi->die_sibling;
9597 /* Return the initial uleb128 in the die at INFO_PTR. */
9600 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9602 unsigned int bytes_read;
9604 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9607 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
9608 Return the corresponding abbrev, or NULL if the number is zero (indicating
9609 an empty DIE). In either case *BYTES_READ will be set to the length of
9610 the initial number. */
9612 static struct abbrev_info *
9613 peek_die_abbrev (const gdb_byte *info_ptr, unsigned int *bytes_read,
9614 struct dwarf2_cu *cu)
9616 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9617 unsigned int abbrev_number;
9618 struct abbrev_info *abbrev;
9620 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9622 if (abbrev_number == 0)
9625 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
9628 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9629 " at offset 0x%x [in module %s]"),
9630 abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9631 to_underlying (cu->header.sect_off), bfd_get_filename (abfd));
9637 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9638 Returns a pointer to the end of a series of DIEs, terminated by an empty
9639 DIE. Any children of the skipped DIEs will also be skipped. */
9641 static const gdb_byte *
9642 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9644 struct dwarf2_cu *cu = reader->cu;
9645 struct abbrev_info *abbrev;
9646 unsigned int bytes_read;
9650 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
9652 return info_ptr + bytes_read;
9654 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9658 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9659 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9660 abbrev corresponding to that skipped uleb128 should be passed in
9661 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9664 static const gdb_byte *
9665 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9666 struct abbrev_info *abbrev)
9668 unsigned int bytes_read;
9669 struct attribute attr;
9670 bfd *abfd = reader->abfd;
9671 struct dwarf2_cu *cu = reader->cu;
9672 const gdb_byte *buffer = reader->buffer;
9673 const gdb_byte *buffer_end = reader->buffer_end;
9674 unsigned int form, i;
9676 for (i = 0; i < abbrev->num_attrs; i++)
9678 /* The only abbrev we care about is DW_AT_sibling. */
9679 if (abbrev->attrs[i].name == DW_AT_sibling)
9681 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9682 if (attr.form == DW_FORM_ref_addr)
9683 complaint (&symfile_complaints,
9684 _("ignoring absolute DW_AT_sibling"));
9687 sect_offset off = dwarf2_get_ref_die_offset (&attr);
9688 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9690 if (sibling_ptr < info_ptr)
9691 complaint (&symfile_complaints,
9692 _("DW_AT_sibling points backwards"));
9693 else if (sibling_ptr > reader->buffer_end)
9694 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9700 /* If it isn't DW_AT_sibling, skip this attribute. */
9701 form = abbrev->attrs[i].form;
9705 case DW_FORM_ref_addr:
9706 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9707 and later it is offset sized. */
9708 if (cu->header.version == 2)
9709 info_ptr += cu->header.addr_size;
9711 info_ptr += cu->header.offset_size;
9713 case DW_FORM_GNU_ref_alt:
9714 info_ptr += cu->header.offset_size;
9717 info_ptr += cu->header.addr_size;
9724 case DW_FORM_flag_present:
9725 case DW_FORM_implicit_const:
9737 case DW_FORM_ref_sig8:
9740 case DW_FORM_data16:
9743 case DW_FORM_string:
9744 read_direct_string (abfd, info_ptr, &bytes_read);
9745 info_ptr += bytes_read;
9747 case DW_FORM_sec_offset:
9749 case DW_FORM_GNU_strp_alt:
9750 info_ptr += cu->header.offset_size;
9752 case DW_FORM_exprloc:
9754 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9755 info_ptr += bytes_read;
9757 case DW_FORM_block1:
9758 info_ptr += 1 + read_1_byte (abfd, info_ptr);
9760 case DW_FORM_block2:
9761 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9763 case DW_FORM_block4:
9764 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9768 case DW_FORM_ref_udata:
9769 case DW_FORM_GNU_addr_index:
9770 case DW_FORM_GNU_str_index:
9771 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9773 case DW_FORM_indirect:
9774 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9775 info_ptr += bytes_read;
9776 /* We need to continue parsing from here, so just go back to
9778 goto skip_attribute;
9781 error (_("Dwarf Error: Cannot handle %s "
9782 "in DWARF reader [in module %s]"),
9783 dwarf_form_name (form),
9784 bfd_get_filename (abfd));
9788 if (abbrev->has_children)
9789 return skip_children (reader, info_ptr);
9794 /* Locate ORIG_PDI's sibling.
9795 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9797 static const gdb_byte *
9798 locate_pdi_sibling (const struct die_reader_specs *reader,
9799 struct partial_die_info *orig_pdi,
9800 const gdb_byte *info_ptr)
9802 /* Do we know the sibling already? */
9804 if (orig_pdi->sibling)
9805 return orig_pdi->sibling;
9807 /* Are there any children to deal with? */
9809 if (!orig_pdi->has_children)
9812 /* Skip the children the long way. */
9814 return skip_children (reader, info_ptr);
9817 /* Expand this partial symbol table into a full symbol table. SELF is
9821 dwarf2_read_symtab (struct partial_symtab *self,
9822 struct objfile *objfile)
9824 struct dwarf2_per_objfile *dwarf2_per_objfile
9825 = get_dwarf2_per_objfile (objfile);
9829 warning (_("bug: psymtab for %s is already read in."),
9836 printf_filtered (_("Reading in symbols for %s..."),
9838 gdb_flush (gdb_stdout);
9841 /* If this psymtab is constructed from a debug-only objfile, the
9842 has_section_at_zero flag will not necessarily be correct. We
9843 can get the correct value for this flag by looking at the data
9844 associated with the (presumably stripped) associated objfile. */
9845 if (objfile->separate_debug_objfile_backlink)
9847 struct dwarf2_per_objfile *dpo_backlink
9848 = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9850 dwarf2_per_objfile->has_section_at_zero
9851 = dpo_backlink->has_section_at_zero;
9854 dwarf2_per_objfile->reading_partial_symbols = 0;
9856 psymtab_to_symtab_1 (self);
9858 /* Finish up the debug error message. */
9860 printf_filtered (_("done.\n"));
9863 process_cu_includes (dwarf2_per_objfile);
9866 /* Reading in full CUs. */
9868 /* Add PER_CU to the queue. */
9871 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9872 enum language pretend_language)
9874 struct dwarf2_queue_item *item;
9877 item = XNEW (struct dwarf2_queue_item);
9878 item->per_cu = per_cu;
9879 item->pretend_language = pretend_language;
9882 if (dwarf2_queue == NULL)
9883 dwarf2_queue = item;
9885 dwarf2_queue_tail->next = item;
9887 dwarf2_queue_tail = item;
9890 /* If PER_CU is not yet queued, add it to the queue.
9891 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9893 The result is non-zero if PER_CU was queued, otherwise the result is zero
9894 meaning either PER_CU is already queued or it is already loaded.
9896 N.B. There is an invariant here that if a CU is queued then it is loaded.
9897 The caller is required to load PER_CU if we return non-zero. */
9900 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9901 struct dwarf2_per_cu_data *per_cu,
9902 enum language pretend_language)
9904 /* We may arrive here during partial symbol reading, if we need full
9905 DIEs to process an unusual case (e.g. template arguments). Do
9906 not queue PER_CU, just tell our caller to load its DIEs. */
9907 if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9909 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9914 /* Mark the dependence relation so that we don't flush PER_CU
9916 if (dependent_cu != NULL)
9917 dwarf2_add_dependence (dependent_cu, per_cu);
9919 /* If it's already on the queue, we have nothing to do. */
9923 /* If the compilation unit is already loaded, just mark it as
9925 if (per_cu->cu != NULL)
9927 per_cu->cu->last_used = 0;
9931 /* Add it to the queue. */
9932 queue_comp_unit (per_cu, pretend_language);
9937 /* Process the queue. */
9940 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9942 struct dwarf2_queue_item *item, *next_item;
9944 if (dwarf_read_debug)
9946 fprintf_unfiltered (gdb_stdlog,
9947 "Expanding one or more symtabs of objfile %s ...\n",
9948 objfile_name (dwarf2_per_objfile->objfile));
9951 /* The queue starts out with one item, but following a DIE reference
9952 may load a new CU, adding it to the end of the queue. */
9953 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9955 if ((dwarf2_per_objfile->using_index
9956 ? !item->per_cu->v.quick->compunit_symtab
9957 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9958 /* Skip dummy CUs. */
9959 && item->per_cu->cu != NULL)
9961 struct dwarf2_per_cu_data *per_cu = item->per_cu;
9962 unsigned int debug_print_threshold;
9965 if (per_cu->is_debug_types)
9967 struct signatured_type *sig_type =
9968 (struct signatured_type *) per_cu;
9970 sprintf (buf, "TU %s at offset 0x%x",
9971 hex_string (sig_type->signature),
9972 to_underlying (per_cu->sect_off));
9973 /* There can be 100s of TUs.
9974 Only print them in verbose mode. */
9975 debug_print_threshold = 2;
9979 sprintf (buf, "CU at offset 0x%x",
9980 to_underlying (per_cu->sect_off));
9981 debug_print_threshold = 1;
9984 if (dwarf_read_debug >= debug_print_threshold)
9985 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9987 if (per_cu->is_debug_types)
9988 process_full_type_unit (per_cu, item->pretend_language);
9990 process_full_comp_unit (per_cu, item->pretend_language);
9992 if (dwarf_read_debug >= debug_print_threshold)
9993 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9996 item->per_cu->queued = 0;
9997 next_item = item->next;
10001 dwarf2_queue_tail = NULL;
10003 if (dwarf_read_debug)
10005 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
10006 objfile_name (dwarf2_per_objfile->objfile));
10010 /* Free all allocated queue entries. This function only releases anything if
10011 an error was thrown; if the queue was processed then it would have been
10012 freed as we went along. */
10015 dwarf2_release_queue (void *dummy)
10017 struct dwarf2_queue_item *item, *last;
10019 item = dwarf2_queue;
10022 /* Anything still marked queued is likely to be in an
10023 inconsistent state, so discard it. */
10024 if (item->per_cu->queued)
10026 if (item->per_cu->cu != NULL)
10027 free_one_cached_comp_unit (item->per_cu);
10028 item->per_cu->queued = 0;
10036 dwarf2_queue = dwarf2_queue_tail = NULL;
10039 /* Read in full symbols for PST, and anything it depends on. */
10042 psymtab_to_symtab_1 (struct partial_symtab *pst)
10044 struct dwarf2_per_cu_data *per_cu;
10050 for (i = 0; i < pst->number_of_dependencies; i++)
10051 if (!pst->dependencies[i]->readin
10052 && pst->dependencies[i]->user == NULL)
10054 /* Inform about additional files that need to be read in. */
10057 /* FIXME: i18n: Need to make this a single string. */
10058 fputs_filtered (" ", gdb_stdout);
10060 fputs_filtered ("and ", gdb_stdout);
10062 printf_filtered ("%s...", pst->dependencies[i]->filename);
10063 wrap_here (""); /* Flush output. */
10064 gdb_flush (gdb_stdout);
10066 psymtab_to_symtab_1 (pst->dependencies[i]);
10069 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
10071 if (per_cu == NULL)
10073 /* It's an include file, no symbols to read for it.
10074 Everything is in the parent symtab. */
10079 dw2_do_instantiate_symtab (per_cu);
10082 /* Trivial hash function for die_info: the hash value of a DIE
10083 is its offset in .debug_info for this objfile. */
10086 die_hash (const void *item)
10088 const struct die_info *die = (const struct die_info *) item;
10090 return to_underlying (die->sect_off);
10093 /* Trivial comparison function for die_info structures: two DIEs
10094 are equal if they have the same offset. */
10097 die_eq (const void *item_lhs, const void *item_rhs)
10099 const struct die_info *die_lhs = (const struct die_info *) item_lhs;
10100 const struct die_info *die_rhs = (const struct die_info *) item_rhs;
10102 return die_lhs->sect_off == die_rhs->sect_off;
10105 /* die_reader_func for load_full_comp_unit.
10106 This is identical to read_signatured_type_reader,
10107 but is kept separate for now. */
10110 load_full_comp_unit_reader (const struct die_reader_specs *reader,
10111 const gdb_byte *info_ptr,
10112 struct die_info *comp_unit_die,
10116 struct dwarf2_cu *cu = reader->cu;
10117 enum language *language_ptr = (enum language *) data;
10119 gdb_assert (cu->die_hash == NULL);
10121 htab_create_alloc_ex (cu->header.length / 12,
10125 &cu->comp_unit_obstack,
10126 hashtab_obstack_allocate,
10127 dummy_obstack_deallocate);
10130 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
10131 &info_ptr, comp_unit_die);
10132 cu->dies = comp_unit_die;
10133 /* comp_unit_die is not stored in die_hash, no need. */
10135 /* We try not to read any attributes in this function, because not
10136 all CUs needed for references have been loaded yet, and symbol
10137 table processing isn't initialized. But we have to set the CU language,
10138 or we won't be able to build types correctly.
10139 Similarly, if we do not read the producer, we can not apply
10140 producer-specific interpretation. */
10141 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
10144 /* Load the DIEs associated with PER_CU into memory. */
10147 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
10148 enum language pretend_language)
10150 gdb_assert (! this_cu->is_debug_types);
10152 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
10153 load_full_comp_unit_reader, &pretend_language);
10156 /* Add a DIE to the delayed physname list. */
10159 add_to_method_list (struct type *type, int fnfield_index, int index,
10160 const char *name, struct die_info *die,
10161 struct dwarf2_cu *cu)
10163 struct delayed_method_info mi;
10165 mi.fnfield_index = fnfield_index;
10169 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
10172 /* A cleanup for freeing the delayed method list. */
10175 free_delayed_list (void *ptr)
10177 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
10178 if (cu->method_list != NULL)
10180 VEC_free (delayed_method_info, cu->method_list);
10181 cu->method_list = NULL;
10185 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
10186 "const" / "volatile". If so, decrements LEN by the length of the
10187 modifier and return true. Otherwise return false. */
10191 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
10193 size_t mod_len = sizeof (mod) - 1;
10194 if (len > mod_len && startswith (physname + (len - mod_len), mod))
10202 /* Compute the physnames of any methods on the CU's method list.
10204 The computation of method physnames is delayed in order to avoid the
10205 (bad) condition that one of the method's formal parameters is of an as yet
10206 incomplete type. */
10209 compute_delayed_physnames (struct dwarf2_cu *cu)
10212 struct delayed_method_info *mi;
10214 /* Only C++ delays computing physnames. */
10215 if (VEC_empty (delayed_method_info, cu->method_list))
10217 gdb_assert (cu->language == language_cplus);
10219 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
10221 const char *physname;
10222 struct fn_fieldlist *fn_flp
10223 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
10224 physname = dwarf2_physname (mi->name, mi->die, cu);
10225 TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi->index)
10226 = physname ? physname : "";
10228 /* Since there's no tag to indicate whether a method is a
10229 const/volatile overload, extract that information out of the
10231 if (physname != NULL)
10233 size_t len = strlen (physname);
10237 if (physname[len] == ')') /* shortcut */
10239 else if (check_modifier (physname, len, " const"))
10240 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi->index) = 1;
10241 else if (check_modifier (physname, len, " volatile"))
10242 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi->index) = 1;
10250 /* Go objects should be embedded in a DW_TAG_module DIE,
10251 and it's not clear if/how imported objects will appear.
10252 To keep Go support simple until that's worked out,
10253 go back through what we've read and create something usable.
10254 We could do this while processing each DIE, and feels kinda cleaner,
10255 but that way is more invasive.
10256 This is to, for example, allow the user to type "p var" or "b main"
10257 without having to specify the package name, and allow lookups
10258 of module.object to work in contexts that use the expression
10262 fixup_go_packaging (struct dwarf2_cu *cu)
10264 char *package_name = NULL;
10265 struct pending *list;
10268 for (list = global_symbols; list != NULL; list = list->next)
10270 for (i = 0; i < list->nsyms; ++i)
10272 struct symbol *sym = list->symbol[i];
10274 if (SYMBOL_LANGUAGE (sym) == language_go
10275 && SYMBOL_CLASS (sym) == LOC_BLOCK)
10277 char *this_package_name = go_symbol_package_name (sym);
10279 if (this_package_name == NULL)
10281 if (package_name == NULL)
10282 package_name = this_package_name;
10285 struct objfile *objfile
10286 = cu->per_cu->dwarf2_per_objfile->objfile;
10287 if (strcmp (package_name, this_package_name) != 0)
10288 complaint (&symfile_complaints,
10289 _("Symtab %s has objects from two different Go packages: %s and %s"),
10290 (symbol_symtab (sym) != NULL
10291 ? symtab_to_filename_for_display
10292 (symbol_symtab (sym))
10293 : objfile_name (objfile)),
10294 this_package_name, package_name);
10295 xfree (this_package_name);
10301 if (package_name != NULL)
10303 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10304 const char *saved_package_name
10305 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
10307 strlen (package_name));
10308 struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
10309 saved_package_name);
10310 struct symbol *sym;
10312 TYPE_TAG_NAME (type) = TYPE_NAME (type);
10314 sym = allocate_symbol (objfile);
10315 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
10316 SYMBOL_SET_NAMES (sym, saved_package_name,
10317 strlen (saved_package_name), 0, objfile);
10318 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
10319 e.g., "main" finds the "main" module and not C's main(). */
10320 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
10321 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
10322 SYMBOL_TYPE (sym) = type;
10324 add_symbol_to_list (sym, &global_symbols);
10326 xfree (package_name);
10330 /* Return the symtab for PER_CU. This works properly regardless of
10331 whether we're using the index or psymtabs. */
10333 static struct compunit_symtab *
10334 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10336 return (per_cu->dwarf2_per_objfile->using_index
10337 ? per_cu->v.quick->compunit_symtab
10338 : per_cu->v.psymtab->compunit_symtab);
10341 /* A helper function for computing the list of all symbol tables
10342 included by PER_CU. */
10345 recursively_compute_inclusions (VEC (compunit_symtab_ptr) **result,
10346 htab_t all_children, htab_t all_type_symtabs,
10347 struct dwarf2_per_cu_data *per_cu,
10348 struct compunit_symtab *immediate_parent)
10352 struct compunit_symtab *cust;
10353 struct dwarf2_per_cu_data *iter;
10355 slot = htab_find_slot (all_children, per_cu, INSERT);
10358 /* This inclusion and its children have been processed. */
10363 /* Only add a CU if it has a symbol table. */
10364 cust = get_compunit_symtab (per_cu);
10367 /* If this is a type unit only add its symbol table if we haven't
10368 seen it yet (type unit per_cu's can share symtabs). */
10369 if (per_cu->is_debug_types)
10371 slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10375 VEC_safe_push (compunit_symtab_ptr, *result, cust);
10376 if (cust->user == NULL)
10377 cust->user = immediate_parent;
10382 VEC_safe_push (compunit_symtab_ptr, *result, cust);
10383 if (cust->user == NULL)
10384 cust->user = immediate_parent;
10389 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10392 recursively_compute_inclusions (result, all_children,
10393 all_type_symtabs, iter, cust);
10397 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10401 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10403 gdb_assert (! per_cu->is_debug_types);
10405 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10408 struct dwarf2_per_cu_data *per_cu_iter;
10409 struct compunit_symtab *compunit_symtab_iter;
10410 VEC (compunit_symtab_ptr) *result_symtabs = NULL;
10411 htab_t all_children, all_type_symtabs;
10412 struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10414 /* If we don't have a symtab, we can just skip this case. */
10418 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10419 NULL, xcalloc, xfree);
10420 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10421 NULL, xcalloc, xfree);
10424 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10428 recursively_compute_inclusions (&result_symtabs, all_children,
10429 all_type_symtabs, per_cu_iter,
10433 /* Now we have a transitive closure of all the included symtabs. */
10434 len = VEC_length (compunit_symtab_ptr, result_symtabs);
10436 = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10437 struct compunit_symtab *, len + 1);
10439 VEC_iterate (compunit_symtab_ptr, result_symtabs, ix,
10440 compunit_symtab_iter);
10442 cust->includes[ix] = compunit_symtab_iter;
10443 cust->includes[len] = NULL;
10445 VEC_free (compunit_symtab_ptr, result_symtabs);
10446 htab_delete (all_children);
10447 htab_delete (all_type_symtabs);
10451 /* Compute the 'includes' field for the symtabs of all the CUs we just
10455 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10458 struct dwarf2_per_cu_data *iter;
10461 VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
10465 if (! iter->is_debug_types)
10466 compute_compunit_symtab_includes (iter);
10469 VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
10472 /* Generate full symbol information for PER_CU, whose DIEs have
10473 already been loaded into memory. */
10476 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10477 enum language pretend_language)
10479 struct dwarf2_cu *cu = per_cu->cu;
10480 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10481 struct objfile *objfile = dwarf2_per_objfile->objfile;
10482 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10483 CORE_ADDR lowpc, highpc;
10484 struct compunit_symtab *cust;
10485 struct cleanup *delayed_list_cleanup;
10486 CORE_ADDR baseaddr;
10487 struct block *static_block;
10490 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10493 scoped_free_pendings free_pending;
10494 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
10496 cu->list_in_scope = &file_symbols;
10498 cu->language = pretend_language;
10499 cu->language_defn = language_def (cu->language);
10501 /* Do line number decoding in read_file_scope () */
10502 process_die (cu->dies, cu);
10504 /* For now fudge the Go package. */
10505 if (cu->language == language_go)
10506 fixup_go_packaging (cu);
10508 /* Now that we have processed all the DIEs in the CU, all the types
10509 should be complete, and it should now be safe to compute all of the
10511 compute_delayed_physnames (cu);
10512 do_cleanups (delayed_list_cleanup);
10514 /* Some compilers don't define a DW_AT_high_pc attribute for the
10515 compilation unit. If the DW_AT_high_pc is missing, synthesize
10516 it, by scanning the DIE's below the compilation unit. */
10517 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10519 addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10520 static_block = end_symtab_get_static_block (addr, 0, 1);
10522 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10523 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10524 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10525 addrmap to help ensure it has an accurate map of pc values belonging to
10527 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10529 cust = end_symtab_from_static_block (static_block,
10530 SECT_OFF_TEXT (objfile), 0);
10534 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10536 /* Set symtab language to language from DW_AT_language. If the
10537 compilation is from a C file generated by language preprocessors, do
10538 not set the language if it was already deduced by start_subfile. */
10539 if (!(cu->language == language_c
10540 && COMPUNIT_FILETABS (cust)->language != language_unknown))
10541 COMPUNIT_FILETABS (cust)->language = cu->language;
10543 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10544 produce DW_AT_location with location lists but it can be possibly
10545 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10546 there were bugs in prologue debug info, fixed later in GCC-4.5
10547 by "unwind info for epilogues" patch (which is not directly related).
10549 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10550 needed, it would be wrong due to missing DW_AT_producer there.
10552 Still one can confuse GDB by using non-standard GCC compilation
10553 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10555 if (cu->has_loclist && gcc_4_minor >= 5)
10556 cust->locations_valid = 1;
10558 if (gcc_4_minor >= 5)
10559 cust->epilogue_unwind_valid = 1;
10561 cust->call_site_htab = cu->call_site_htab;
10564 if (dwarf2_per_objfile->using_index)
10565 per_cu->v.quick->compunit_symtab = cust;
10568 struct partial_symtab *pst = per_cu->v.psymtab;
10569 pst->compunit_symtab = cust;
10573 /* Push it for inclusion processing later. */
10574 VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
10577 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10578 already been loaded into memory. */
10581 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10582 enum language pretend_language)
10584 struct dwarf2_cu *cu = per_cu->cu;
10585 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10586 struct objfile *objfile = dwarf2_per_objfile->objfile;
10587 struct compunit_symtab *cust;
10588 struct cleanup *delayed_list_cleanup;
10589 struct signatured_type *sig_type;
10591 gdb_assert (per_cu->is_debug_types);
10592 sig_type = (struct signatured_type *) per_cu;
10595 scoped_free_pendings free_pending;
10596 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
10598 cu->list_in_scope = &file_symbols;
10600 cu->language = pretend_language;
10601 cu->language_defn = language_def (cu->language);
10603 /* The symbol tables are set up in read_type_unit_scope. */
10604 process_die (cu->dies, cu);
10606 /* For now fudge the Go package. */
10607 if (cu->language == language_go)
10608 fixup_go_packaging (cu);
10610 /* Now that we have processed all the DIEs in the CU, all the types
10611 should be complete, and it should now be safe to compute all of the
10613 compute_delayed_physnames (cu);
10614 do_cleanups (delayed_list_cleanup);
10616 /* TUs share symbol tables.
10617 If this is the first TU to use this symtab, complete the construction
10618 of it with end_expandable_symtab. Otherwise, complete the addition of
10619 this TU's symbols to the existing symtab. */
10620 if (sig_type->type_unit_group->compunit_symtab == NULL)
10622 cust = end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10623 sig_type->type_unit_group->compunit_symtab = cust;
10627 /* Set symtab language to language from DW_AT_language. If the
10628 compilation is from a C file generated by language preprocessors,
10629 do not set the language if it was already deduced by
10631 if (!(cu->language == language_c
10632 && COMPUNIT_FILETABS (cust)->language != language_c))
10633 COMPUNIT_FILETABS (cust)->language = cu->language;
10638 augment_type_symtab ();
10639 cust = sig_type->type_unit_group->compunit_symtab;
10642 if (dwarf2_per_objfile->using_index)
10643 per_cu->v.quick->compunit_symtab = cust;
10646 struct partial_symtab *pst = per_cu->v.psymtab;
10647 pst->compunit_symtab = cust;
10652 /* Process an imported unit DIE. */
10655 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10657 struct attribute *attr;
10659 /* For now we don't handle imported units in type units. */
10660 if (cu->per_cu->is_debug_types)
10662 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10663 " supported in type units [in module %s]"),
10664 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10667 attr = dwarf2_attr (die, DW_AT_import, cu);
10670 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10671 bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10672 dwarf2_per_cu_data *per_cu
10673 = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10674 cu->per_cu->dwarf2_per_objfile);
10676 /* If necessary, add it to the queue and load its DIEs. */
10677 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10678 load_full_comp_unit (per_cu, cu->language);
10680 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10685 /* RAII object that represents a process_die scope: i.e.,
10686 starts/finishes processing a DIE. */
10687 class process_die_scope
10690 process_die_scope (die_info *die, dwarf2_cu *cu)
10691 : m_die (die), m_cu (cu)
10693 /* We should only be processing DIEs not already in process. */
10694 gdb_assert (!m_die->in_process);
10695 m_die->in_process = true;
10698 ~process_die_scope ()
10700 m_die->in_process = false;
10702 /* If we're done processing the DIE for the CU that owns the line
10703 header, we don't need the line header anymore. */
10704 if (m_cu->line_header_die_owner == m_die)
10706 delete m_cu->line_header;
10707 m_cu->line_header = NULL;
10708 m_cu->line_header_die_owner = NULL;
10717 /* Process a die and its children. */
10720 process_die (struct die_info *die, struct dwarf2_cu *cu)
10722 process_die_scope scope (die, cu);
10726 case DW_TAG_padding:
10728 case DW_TAG_compile_unit:
10729 case DW_TAG_partial_unit:
10730 read_file_scope (die, cu);
10732 case DW_TAG_type_unit:
10733 read_type_unit_scope (die, cu);
10735 case DW_TAG_subprogram:
10736 case DW_TAG_inlined_subroutine:
10737 read_func_scope (die, cu);
10739 case DW_TAG_lexical_block:
10740 case DW_TAG_try_block:
10741 case DW_TAG_catch_block:
10742 read_lexical_block_scope (die, cu);
10744 case DW_TAG_call_site:
10745 case DW_TAG_GNU_call_site:
10746 read_call_site_scope (die, cu);
10748 case DW_TAG_class_type:
10749 case DW_TAG_interface_type:
10750 case DW_TAG_structure_type:
10751 case DW_TAG_union_type:
10752 process_structure_scope (die, cu);
10754 case DW_TAG_enumeration_type:
10755 process_enumeration_scope (die, cu);
10758 /* These dies have a type, but processing them does not create
10759 a symbol or recurse to process the children. Therefore we can
10760 read them on-demand through read_type_die. */
10761 case DW_TAG_subroutine_type:
10762 case DW_TAG_set_type:
10763 case DW_TAG_array_type:
10764 case DW_TAG_pointer_type:
10765 case DW_TAG_ptr_to_member_type:
10766 case DW_TAG_reference_type:
10767 case DW_TAG_rvalue_reference_type:
10768 case DW_TAG_string_type:
10771 case DW_TAG_base_type:
10772 case DW_TAG_subrange_type:
10773 case DW_TAG_typedef:
10774 /* Add a typedef symbol for the type definition, if it has a
10776 new_symbol (die, read_type_die (die, cu), cu);
10778 case DW_TAG_common_block:
10779 read_common_block (die, cu);
10781 case DW_TAG_common_inclusion:
10783 case DW_TAG_namespace:
10784 cu->processing_has_namespace_info = 1;
10785 read_namespace (die, cu);
10787 case DW_TAG_module:
10788 cu->processing_has_namespace_info = 1;
10789 read_module (die, cu);
10791 case DW_TAG_imported_declaration:
10792 cu->processing_has_namespace_info = 1;
10793 if (read_namespace_alias (die, cu))
10795 /* The declaration is not a global namespace alias: fall through. */
10796 case DW_TAG_imported_module:
10797 cu->processing_has_namespace_info = 1;
10798 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10799 || cu->language != language_fortran))
10800 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
10801 dwarf_tag_name (die->tag));
10802 read_import_statement (die, cu);
10805 case DW_TAG_imported_unit:
10806 process_imported_unit_die (die, cu);
10809 case DW_TAG_variable:
10810 read_variable (die, cu);
10814 new_symbol (die, NULL, cu);
10819 /* DWARF name computation. */
10821 /* A helper function for dwarf2_compute_name which determines whether DIE
10822 needs to have the name of the scope prepended to the name listed in the
10826 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10828 struct attribute *attr;
10832 case DW_TAG_namespace:
10833 case DW_TAG_typedef:
10834 case DW_TAG_class_type:
10835 case DW_TAG_interface_type:
10836 case DW_TAG_structure_type:
10837 case DW_TAG_union_type:
10838 case DW_TAG_enumeration_type:
10839 case DW_TAG_enumerator:
10840 case DW_TAG_subprogram:
10841 case DW_TAG_inlined_subroutine:
10842 case DW_TAG_member:
10843 case DW_TAG_imported_declaration:
10846 case DW_TAG_variable:
10847 case DW_TAG_constant:
10848 /* We only need to prefix "globally" visible variables. These include
10849 any variable marked with DW_AT_external or any variable that
10850 lives in a namespace. [Variables in anonymous namespaces
10851 require prefixing, but they are not DW_AT_external.] */
10853 if (dwarf2_attr (die, DW_AT_specification, cu))
10855 struct dwarf2_cu *spec_cu = cu;
10857 return die_needs_namespace (die_specification (die, &spec_cu),
10861 attr = dwarf2_attr (die, DW_AT_external, cu);
10862 if (attr == NULL && die->parent->tag != DW_TAG_namespace
10863 && die->parent->tag != DW_TAG_module)
10865 /* A variable in a lexical block of some kind does not need a
10866 namespace, even though in C++ such variables may be external
10867 and have a mangled name. */
10868 if (die->parent->tag == DW_TAG_lexical_block
10869 || die->parent->tag == DW_TAG_try_block
10870 || die->parent->tag == DW_TAG_catch_block
10871 || die->parent->tag == DW_TAG_subprogram)
10880 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10881 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10882 defined for the given DIE. */
10884 static struct attribute *
10885 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10887 struct attribute *attr;
10889 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10891 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10896 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10897 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10898 defined for the given DIE. */
10900 static const char *
10901 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10903 const char *linkage_name;
10905 linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10906 if (linkage_name == NULL)
10907 linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10909 return linkage_name;
10912 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10913 compute the physname for the object, which include a method's:
10914 - formal parameters (C++),
10915 - receiver type (Go),
10917 The term "physname" is a bit confusing.
10918 For C++, for example, it is the demangled name.
10919 For Go, for example, it's the mangled name.
10921 For Ada, return the DIE's linkage name rather than the fully qualified
10922 name. PHYSNAME is ignored..
10924 The result is allocated on the objfile_obstack and canonicalized. */
10926 static const char *
10927 dwarf2_compute_name (const char *name,
10928 struct die_info *die, struct dwarf2_cu *cu,
10931 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10934 name = dwarf2_name (die, cu);
10936 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10937 but otherwise compute it by typename_concat inside GDB.
10938 FIXME: Actually this is not really true, or at least not always true.
10939 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10940 Fortran names because there is no mangling standard. So new_symbol
10941 will set the demangled name to the result of dwarf2_full_name, and it is
10942 the demangled name that GDB uses if it exists. */
10943 if (cu->language == language_ada
10944 || (cu->language == language_fortran && physname))
10946 /* For Ada unit, we prefer the linkage name over the name, as
10947 the former contains the exported name, which the user expects
10948 to be able to reference. Ideally, we want the user to be able
10949 to reference this entity using either natural or linkage name,
10950 but we haven't started looking at this enhancement yet. */
10951 const char *linkage_name = dw2_linkage_name (die, cu);
10953 if (linkage_name != NULL)
10954 return linkage_name;
10957 /* These are the only languages we know how to qualify names in. */
10959 && (cu->language == language_cplus
10960 || cu->language == language_fortran || cu->language == language_d
10961 || cu->language == language_rust))
10963 if (die_needs_namespace (die, cu))
10965 const char *prefix;
10966 const char *canonical_name = NULL;
10970 prefix = determine_prefix (die, cu);
10971 if (*prefix != '\0')
10973 char *prefixed_name = typename_concat (NULL, prefix, name,
10976 buf.puts (prefixed_name);
10977 xfree (prefixed_name);
10982 /* Template parameters may be specified in the DIE's DW_AT_name, or
10983 as children with DW_TAG_template_type_param or
10984 DW_TAG_value_type_param. If the latter, add them to the name
10985 here. If the name already has template parameters, then
10986 skip this step; some versions of GCC emit both, and
10987 it is more efficient to use the pre-computed name.
10989 Something to keep in mind about this process: it is very
10990 unlikely, or in some cases downright impossible, to produce
10991 something that will match the mangled name of a function.
10992 If the definition of the function has the same debug info,
10993 we should be able to match up with it anyway. But fallbacks
10994 using the minimal symbol, for instance to find a method
10995 implemented in a stripped copy of libstdc++, will not work.
10996 If we do not have debug info for the definition, we will have to
10997 match them up some other way.
10999 When we do name matching there is a related problem with function
11000 templates; two instantiated function templates are allowed to
11001 differ only by their return types, which we do not add here. */
11003 if (cu->language == language_cplus && strchr (name, '<') == NULL)
11005 struct attribute *attr;
11006 struct die_info *child;
11009 die->building_fullname = 1;
11011 for (child = die->child; child != NULL; child = child->sibling)
11015 const gdb_byte *bytes;
11016 struct dwarf2_locexpr_baton *baton;
11019 if (child->tag != DW_TAG_template_type_param
11020 && child->tag != DW_TAG_template_value_param)
11031 attr = dwarf2_attr (child, DW_AT_type, cu);
11034 complaint (&symfile_complaints,
11035 _("template parameter missing DW_AT_type"));
11036 buf.puts ("UNKNOWN_TYPE");
11039 type = die_type (child, cu);
11041 if (child->tag == DW_TAG_template_type_param)
11043 c_print_type (type, "", &buf, -1, 0, &type_print_raw_options);
11047 attr = dwarf2_attr (child, DW_AT_const_value, cu);
11050 complaint (&symfile_complaints,
11051 _("template parameter missing "
11052 "DW_AT_const_value"));
11053 buf.puts ("UNKNOWN_VALUE");
11057 dwarf2_const_value_attr (attr, type, name,
11058 &cu->comp_unit_obstack, cu,
11059 &value, &bytes, &baton);
11061 if (TYPE_NOSIGN (type))
11062 /* GDB prints characters as NUMBER 'CHAR'. If that's
11063 changed, this can use value_print instead. */
11064 c_printchar (value, type, &buf);
11067 struct value_print_options opts;
11070 v = dwarf2_evaluate_loc_desc (type, NULL,
11074 else if (bytes != NULL)
11076 v = allocate_value (type);
11077 memcpy (value_contents_writeable (v), bytes,
11078 TYPE_LENGTH (type));
11081 v = value_from_longest (type, value);
11083 /* Specify decimal so that we do not depend on
11085 get_formatted_print_options (&opts, 'd');
11087 value_print (v, &buf, &opts);
11093 die->building_fullname = 0;
11097 /* Close the argument list, with a space if necessary
11098 (nested templates). */
11099 if (!buf.empty () && buf.string ().back () == '>')
11106 /* For C++ methods, append formal parameter type
11107 information, if PHYSNAME. */
11109 if (physname && die->tag == DW_TAG_subprogram
11110 && cu->language == language_cplus)
11112 struct type *type = read_type_die (die, cu);
11114 c_type_print_args (type, &buf, 1, cu->language,
11115 &type_print_raw_options);
11117 if (cu->language == language_cplus)
11119 /* Assume that an artificial first parameter is
11120 "this", but do not crash if it is not. RealView
11121 marks unnamed (and thus unused) parameters as
11122 artificial; there is no way to differentiate
11124 if (TYPE_NFIELDS (type) > 0
11125 && TYPE_FIELD_ARTIFICIAL (type, 0)
11126 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
11127 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
11129 buf.puts (" const");
11133 const std::string &intermediate_name = buf.string ();
11135 if (cu->language == language_cplus)
11137 = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
11138 &objfile->per_bfd->storage_obstack);
11140 /* If we only computed INTERMEDIATE_NAME, or if
11141 INTERMEDIATE_NAME is already canonical, then we need to
11142 copy it to the appropriate obstack. */
11143 if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
11144 name = ((const char *)
11145 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11146 intermediate_name.c_str (),
11147 intermediate_name.length ()));
11149 name = canonical_name;
11156 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11157 If scope qualifiers are appropriate they will be added. The result
11158 will be allocated on the storage_obstack, or NULL if the DIE does
11159 not have a name. NAME may either be from a previous call to
11160 dwarf2_name or NULL.
11162 The output string will be canonicalized (if C++). */
11164 static const char *
11165 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11167 return dwarf2_compute_name (name, die, cu, 0);
11170 /* Construct a physname for the given DIE in CU. NAME may either be
11171 from a previous call to dwarf2_name or NULL. The result will be
11172 allocated on the objfile_objstack or NULL if the DIE does not have a
11175 The output string will be canonicalized (if C++). */
11177 static const char *
11178 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11180 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11181 const char *retval, *mangled = NULL, *canon = NULL;
11184 /* In this case dwarf2_compute_name is just a shortcut not building anything
11186 if (!die_needs_namespace (die, cu))
11187 return dwarf2_compute_name (name, die, cu, 1);
11189 mangled = dw2_linkage_name (die, cu);
11191 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11192 See https://github.com/rust-lang/rust/issues/32925. */
11193 if (cu->language == language_rust && mangled != NULL
11194 && strchr (mangled, '{') != NULL)
11197 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11199 gdb::unique_xmalloc_ptr<char> demangled;
11200 if (mangled != NULL)
11202 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
11203 type. It is easier for GDB users to search for such functions as
11204 `name(params)' than `long name(params)'. In such case the minimal
11205 symbol names do not match the full symbol names but for template
11206 functions there is never a need to look up their definition from their
11207 declaration so the only disadvantage remains the minimal symbol
11208 variant `long name(params)' does not have the proper inferior type.
11211 if (cu->language == language_go)
11213 /* This is a lie, but we already lie to the caller new_symbol.
11214 new_symbol assumes we return the mangled name.
11215 This just undoes that lie until things are cleaned up. */
11219 demangled.reset (gdb_demangle (mangled,
11220 (DMGL_PARAMS | DMGL_ANSI
11221 | DMGL_RET_DROP)));
11224 canon = demangled.get ();
11232 if (canon == NULL || check_physname)
11234 const char *physname = dwarf2_compute_name (name, die, cu, 1);
11236 if (canon != NULL && strcmp (physname, canon) != 0)
11238 /* It may not mean a bug in GDB. The compiler could also
11239 compute DW_AT_linkage_name incorrectly. But in such case
11240 GDB would need to be bug-to-bug compatible. */
11242 complaint (&symfile_complaints,
11243 _("Computed physname <%s> does not match demangled <%s> "
11244 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
11245 physname, canon, mangled, to_underlying (die->sect_off),
11246 objfile_name (objfile));
11248 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11249 is available here - over computed PHYSNAME. It is safer
11250 against both buggy GDB and buggy compilers. */
11264 retval = ((const char *)
11265 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11266 retval, strlen (retval)));
11271 /* Inspect DIE in CU for a namespace alias. If one exists, record
11272 a new symbol for it.
11274 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11277 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11279 struct attribute *attr;
11281 /* If the die does not have a name, this is not a namespace
11283 attr = dwarf2_attr (die, DW_AT_name, cu);
11287 struct die_info *d = die;
11288 struct dwarf2_cu *imported_cu = cu;
11290 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11291 keep inspecting DIEs until we hit the underlying import. */
11292 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11293 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11295 attr = dwarf2_attr (d, DW_AT_import, cu);
11299 d = follow_die_ref (d, attr, &imported_cu);
11300 if (d->tag != DW_TAG_imported_declaration)
11304 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11306 complaint (&symfile_complaints,
11307 _("DIE at 0x%x has too many recursively imported "
11308 "declarations"), to_underlying (d->sect_off));
11315 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11317 type = get_die_type_at_offset (sect_off, cu->per_cu);
11318 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11320 /* This declaration is a global namespace alias. Add
11321 a symbol for it whose type is the aliased namespace. */
11322 new_symbol (die, type, cu);
11331 /* Return the using directives repository (global or local?) to use in the
11332 current context for LANGUAGE.
11334 For Ada, imported declarations can materialize renamings, which *may* be
11335 global. However it is impossible (for now?) in DWARF to distinguish
11336 "external" imported declarations and "static" ones. As all imported
11337 declarations seem to be static in all other languages, make them all CU-wide
11338 global only in Ada. */
11340 static struct using_direct **
11341 using_directives (enum language language)
11343 if (language == language_ada && context_stack_depth == 0)
11344 return &global_using_directives;
11346 return &local_using_directives;
11349 /* Read the import statement specified by the given die and record it. */
11352 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11354 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11355 struct attribute *import_attr;
11356 struct die_info *imported_die, *child_die;
11357 struct dwarf2_cu *imported_cu;
11358 const char *imported_name;
11359 const char *imported_name_prefix;
11360 const char *canonical_name;
11361 const char *import_alias;
11362 const char *imported_declaration = NULL;
11363 const char *import_prefix;
11364 std::vector<const char *> excludes;
11366 import_attr = dwarf2_attr (die, DW_AT_import, cu);
11367 if (import_attr == NULL)
11369 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
11370 dwarf_tag_name (die->tag));
11375 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11376 imported_name = dwarf2_name (imported_die, imported_cu);
11377 if (imported_name == NULL)
11379 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11381 The import in the following code:
11395 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11396 <52> DW_AT_decl_file : 1
11397 <53> DW_AT_decl_line : 6
11398 <54> DW_AT_import : <0x75>
11399 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11400 <59> DW_AT_name : B
11401 <5b> DW_AT_decl_file : 1
11402 <5c> DW_AT_decl_line : 2
11403 <5d> DW_AT_type : <0x6e>
11405 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11406 <76> DW_AT_byte_size : 4
11407 <77> DW_AT_encoding : 5 (signed)
11409 imports the wrong die ( 0x75 instead of 0x58 ).
11410 This case will be ignored until the gcc bug is fixed. */
11414 /* Figure out the local name after import. */
11415 import_alias = dwarf2_name (die, cu);
11417 /* Figure out where the statement is being imported to. */
11418 import_prefix = determine_prefix (die, cu);
11420 /* Figure out what the scope of the imported die is and prepend it
11421 to the name of the imported die. */
11422 imported_name_prefix = determine_prefix (imported_die, imported_cu);
11424 if (imported_die->tag != DW_TAG_namespace
11425 && imported_die->tag != DW_TAG_module)
11427 imported_declaration = imported_name;
11428 canonical_name = imported_name_prefix;
11430 else if (strlen (imported_name_prefix) > 0)
11431 canonical_name = obconcat (&objfile->objfile_obstack,
11432 imported_name_prefix,
11433 (cu->language == language_d ? "." : "::"),
11434 imported_name, (char *) NULL);
11436 canonical_name = imported_name;
11438 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11439 for (child_die = die->child; child_die && child_die->tag;
11440 child_die = sibling_die (child_die))
11442 /* DWARF-4: A Fortran use statement with a “rename list” may be
11443 represented by an imported module entry with an import attribute
11444 referring to the module and owned entries corresponding to those
11445 entities that are renamed as part of being imported. */
11447 if (child_die->tag != DW_TAG_imported_declaration)
11449 complaint (&symfile_complaints,
11450 _("child DW_TAG_imported_declaration expected "
11451 "- DIE at 0x%x [in module %s]"),
11452 to_underlying (child_die->sect_off), objfile_name (objfile));
11456 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11457 if (import_attr == NULL)
11459 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
11460 dwarf_tag_name (child_die->tag));
11465 imported_die = follow_die_ref_or_sig (child_die, import_attr,
11467 imported_name = dwarf2_name (imported_die, imported_cu);
11468 if (imported_name == NULL)
11470 complaint (&symfile_complaints,
11471 _("child DW_TAG_imported_declaration has unknown "
11472 "imported name - DIE at 0x%x [in module %s]"),
11473 to_underlying (child_die->sect_off), objfile_name (objfile));
11477 excludes.push_back (imported_name);
11479 process_die (child_die, cu);
11482 add_using_directive (using_directives (cu->language),
11486 imported_declaration,
11489 &objfile->objfile_obstack);
11492 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11493 types, but gives them a size of zero. Starting with version 14,
11494 ICC is compatible with GCC. */
11497 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11499 if (!cu->checked_producer)
11500 check_producer (cu);
11502 return cu->producer_is_icc_lt_14;
11505 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11506 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11507 this, it was first present in GCC release 4.3.0. */
11510 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11512 if (!cu->checked_producer)
11513 check_producer (cu);
11515 return cu->producer_is_gcc_lt_4_3;
11518 static file_and_directory
11519 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11521 file_and_directory res;
11523 /* Find the filename. Do not use dwarf2_name here, since the filename
11524 is not a source language identifier. */
11525 res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11526 res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11528 if (res.comp_dir == NULL
11529 && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11530 && IS_ABSOLUTE_PATH (res.name))
11532 res.comp_dir_storage = ldirname (res.name);
11533 if (!res.comp_dir_storage.empty ())
11534 res.comp_dir = res.comp_dir_storage.c_str ();
11536 if (res.comp_dir != NULL)
11538 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11539 directory, get rid of it. */
11540 const char *cp = strchr (res.comp_dir, ':');
11542 if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11543 res.comp_dir = cp + 1;
11546 if (res.name == NULL)
11547 res.name = "<unknown>";
11552 /* Handle DW_AT_stmt_list for a compilation unit.
11553 DIE is the DW_TAG_compile_unit die for CU.
11554 COMP_DIR is the compilation directory. LOWPC is passed to
11555 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11558 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11559 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11561 struct dwarf2_per_objfile *dwarf2_per_objfile
11562 = cu->per_cu->dwarf2_per_objfile;
11563 struct objfile *objfile = dwarf2_per_objfile->objfile;
11564 struct attribute *attr;
11565 struct line_header line_header_local;
11566 hashval_t line_header_local_hash;
11568 int decode_mapping;
11570 gdb_assert (! cu->per_cu->is_debug_types);
11572 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11576 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11578 /* The line header hash table is only created if needed (it exists to
11579 prevent redundant reading of the line table for partial_units).
11580 If we're given a partial_unit, we'll need it. If we're given a
11581 compile_unit, then use the line header hash table if it's already
11582 created, but don't create one just yet. */
11584 if (dwarf2_per_objfile->line_header_hash == NULL
11585 && die->tag == DW_TAG_partial_unit)
11587 dwarf2_per_objfile->line_header_hash
11588 = htab_create_alloc_ex (127, line_header_hash_voidp,
11589 line_header_eq_voidp,
11590 free_line_header_voidp,
11591 &objfile->objfile_obstack,
11592 hashtab_obstack_allocate,
11593 dummy_obstack_deallocate);
11596 line_header_local.sect_off = line_offset;
11597 line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11598 line_header_local_hash = line_header_hash (&line_header_local);
11599 if (dwarf2_per_objfile->line_header_hash != NULL)
11601 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11602 &line_header_local,
11603 line_header_local_hash, NO_INSERT);
11605 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11606 is not present in *SLOT (since if there is something in *SLOT then
11607 it will be for a partial_unit). */
11608 if (die->tag == DW_TAG_partial_unit && slot != NULL)
11610 gdb_assert (*slot != NULL);
11611 cu->line_header = (struct line_header *) *slot;
11616 /* dwarf_decode_line_header does not yet provide sufficient information.
11617 We always have to call also dwarf_decode_lines for it. */
11618 line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11622 cu->line_header = lh.release ();
11623 cu->line_header_die_owner = die;
11625 if (dwarf2_per_objfile->line_header_hash == NULL)
11629 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11630 &line_header_local,
11631 line_header_local_hash, INSERT);
11632 gdb_assert (slot != NULL);
11634 if (slot != NULL && *slot == NULL)
11636 /* This newly decoded line number information unit will be owned
11637 by line_header_hash hash table. */
11638 *slot = cu->line_header;
11639 cu->line_header_die_owner = NULL;
11643 /* We cannot free any current entry in (*slot) as that struct line_header
11644 may be already used by multiple CUs. Create only temporary decoded
11645 line_header for this CU - it may happen at most once for each line
11646 number information unit. And if we're not using line_header_hash
11647 then this is what we want as well. */
11648 gdb_assert (die->tag != DW_TAG_partial_unit);
11650 decode_mapping = (die->tag != DW_TAG_partial_unit);
11651 dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11656 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11659 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11661 struct dwarf2_per_objfile *dwarf2_per_objfile
11662 = cu->per_cu->dwarf2_per_objfile;
11663 struct objfile *objfile = dwarf2_per_objfile->objfile;
11664 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11665 CORE_ADDR lowpc = ((CORE_ADDR) -1);
11666 CORE_ADDR highpc = ((CORE_ADDR) 0);
11667 struct attribute *attr;
11668 struct die_info *child_die;
11669 CORE_ADDR baseaddr;
11671 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11673 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11675 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11676 from finish_block. */
11677 if (lowpc == ((CORE_ADDR) -1))
11679 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11681 file_and_directory fnd = find_file_and_directory (die, cu);
11683 prepare_one_comp_unit (cu, die, cu->language);
11685 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11686 standardised yet. As a workaround for the language detection we fall
11687 back to the DW_AT_producer string. */
11688 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11689 cu->language = language_opencl;
11691 /* Similar hack for Go. */
11692 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11693 set_cu_language (DW_LANG_Go, cu);
11695 dwarf2_start_symtab (cu, fnd.name, fnd.comp_dir, lowpc);
11697 /* Decode line number information if present. We do this before
11698 processing child DIEs, so that the line header table is available
11699 for DW_AT_decl_file. */
11700 handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11702 /* Process all dies in compilation unit. */
11703 if (die->child != NULL)
11705 child_die = die->child;
11706 while (child_die && child_die->tag)
11708 process_die (child_die, cu);
11709 child_die = sibling_die (child_die);
11713 /* Decode macro information, if present. Dwarf 2 macro information
11714 refers to information in the line number info statement program
11715 header, so we can only read it if we've read the header
11717 attr = dwarf2_attr (die, DW_AT_macros, cu);
11719 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11720 if (attr && cu->line_header)
11722 if (dwarf2_attr (die, DW_AT_macro_info, cu))
11723 complaint (&symfile_complaints,
11724 _("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11726 dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11730 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11731 if (attr && cu->line_header)
11733 unsigned int macro_offset = DW_UNSND (attr);
11735 dwarf_decode_macros (cu, macro_offset, 0);
11740 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
11741 Create the set of symtabs used by this TU, or if this TU is sharing
11742 symtabs with another TU and the symtabs have already been created
11743 then restore those symtabs in the line header.
11744 We don't need the pc/line-number mapping for type units. */
11747 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
11749 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
11750 struct type_unit_group *tu_group;
11752 struct attribute *attr;
11754 struct signatured_type *sig_type;
11756 gdb_assert (per_cu->is_debug_types);
11757 sig_type = (struct signatured_type *) per_cu;
11759 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11761 /* If we're using .gdb_index (includes -readnow) then
11762 per_cu->type_unit_group may not have been set up yet. */
11763 if (sig_type->type_unit_group == NULL)
11764 sig_type->type_unit_group = get_type_unit_group (cu, attr);
11765 tu_group = sig_type->type_unit_group;
11767 /* If we've already processed this stmt_list there's no real need to
11768 do it again, we could fake it and just recreate the part we need
11769 (file name,index -> symtab mapping). If data shows this optimization
11770 is useful we can do it then. */
11771 first_time = tu_group->compunit_symtab == NULL;
11773 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11778 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11779 lh = dwarf_decode_line_header (line_offset, cu);
11784 dwarf2_start_symtab (cu, "", NULL, 0);
11787 gdb_assert (tu_group->symtabs == NULL);
11788 restart_symtab (tu_group->compunit_symtab, "", 0);
11793 cu->line_header = lh.release ();
11794 cu->line_header_die_owner = die;
11798 struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
11800 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11801 still initializing it, and our caller (a few levels up)
11802 process_full_type_unit still needs to know if this is the first
11805 tu_group->num_symtabs = cu->line_header->file_names.size ();
11806 tu_group->symtabs = XNEWVEC (struct symtab *,
11807 cu->line_header->file_names.size ());
11809 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11811 file_entry &fe = cu->line_header->file_names[i];
11813 dwarf2_start_subfile (fe.name, fe.include_dir (cu->line_header));
11815 if (current_subfile->symtab == NULL)
11817 /* NOTE: start_subfile will recognize when it's been
11818 passed a file it has already seen. So we can't
11819 assume there's a simple mapping from
11820 cu->line_header->file_names to subfiles, plus
11821 cu->line_header->file_names may contain dups. */
11822 current_subfile->symtab
11823 = allocate_symtab (cust, current_subfile->name);
11826 fe.symtab = current_subfile->symtab;
11827 tu_group->symtabs[i] = fe.symtab;
11832 restart_symtab (tu_group->compunit_symtab, "", 0);
11834 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11836 file_entry &fe = cu->line_header->file_names[i];
11838 fe.symtab = tu_group->symtabs[i];
11842 /* The main symtab is allocated last. Type units don't have DW_AT_name
11843 so they don't have a "real" (so to speak) symtab anyway.
11844 There is later code that will assign the main symtab to all symbols
11845 that don't have one. We need to handle the case of a symbol with a
11846 missing symtab (DW_AT_decl_file) anyway. */
11849 /* Process DW_TAG_type_unit.
11850 For TUs we want to skip the first top level sibling if it's not the
11851 actual type being defined by this TU. In this case the first top
11852 level sibling is there to provide context only. */
11855 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11857 struct die_info *child_die;
11859 prepare_one_comp_unit (cu, die, language_minimal);
11861 /* Initialize (or reinitialize) the machinery for building symtabs.
11862 We do this before processing child DIEs, so that the line header table
11863 is available for DW_AT_decl_file. */
11864 setup_type_unit_groups (die, cu);
11866 if (die->child != NULL)
11868 child_die = die->child;
11869 while (child_die && child_die->tag)
11871 process_die (child_die, cu);
11872 child_die = sibling_die (child_die);
11879 http://gcc.gnu.org/wiki/DebugFission
11880 http://gcc.gnu.org/wiki/DebugFissionDWP
11882 To simplify handling of both DWO files ("object" files with the DWARF info)
11883 and DWP files (a file with the DWOs packaged up into one file), we treat
11884 DWP files as having a collection of virtual DWO files. */
11887 hash_dwo_file (const void *item)
11889 const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11892 hash = htab_hash_string (dwo_file->dwo_name);
11893 if (dwo_file->comp_dir != NULL)
11894 hash += htab_hash_string (dwo_file->comp_dir);
11899 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11901 const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11902 const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11904 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11906 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11907 return lhs->comp_dir == rhs->comp_dir;
11908 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11911 /* Allocate a hash table for DWO files. */
11914 allocate_dwo_file_hash_table (struct objfile *objfile)
11916 return htab_create_alloc_ex (41,
11920 &objfile->objfile_obstack,
11921 hashtab_obstack_allocate,
11922 dummy_obstack_deallocate);
11925 /* Lookup DWO file DWO_NAME. */
11928 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11929 const char *dwo_name,
11930 const char *comp_dir)
11932 struct dwo_file find_entry;
11935 if (dwarf2_per_objfile->dwo_files == NULL)
11936 dwarf2_per_objfile->dwo_files
11937 = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11939 memset (&find_entry, 0, sizeof (find_entry));
11940 find_entry.dwo_name = dwo_name;
11941 find_entry.comp_dir = comp_dir;
11942 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11948 hash_dwo_unit (const void *item)
11950 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11952 /* This drops the top 32 bits of the id, but is ok for a hash. */
11953 return dwo_unit->signature;
11957 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11959 const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11960 const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11962 /* The signature is assumed to be unique within the DWO file.
11963 So while object file CU dwo_id's always have the value zero,
11964 that's OK, assuming each object file DWO file has only one CU,
11965 and that's the rule for now. */
11966 return lhs->signature == rhs->signature;
11969 /* Allocate a hash table for DWO CUs,TUs.
11970 There is one of these tables for each of CUs,TUs for each DWO file. */
11973 allocate_dwo_unit_table (struct objfile *objfile)
11975 /* Start out with a pretty small number.
11976 Generally DWO files contain only one CU and maybe some TUs. */
11977 return htab_create_alloc_ex (3,
11981 &objfile->objfile_obstack,
11982 hashtab_obstack_allocate,
11983 dummy_obstack_deallocate);
11986 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11988 struct create_dwo_cu_data
11990 struct dwo_file *dwo_file;
11991 struct dwo_unit dwo_unit;
11994 /* die_reader_func for create_dwo_cu. */
11997 create_dwo_cu_reader (const struct die_reader_specs *reader,
11998 const gdb_byte *info_ptr,
11999 struct die_info *comp_unit_die,
12003 struct dwarf2_cu *cu = reader->cu;
12004 sect_offset sect_off = cu->per_cu->sect_off;
12005 struct dwarf2_section_info *section = cu->per_cu->section;
12006 struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
12007 struct dwo_file *dwo_file = data->dwo_file;
12008 struct dwo_unit *dwo_unit = &data->dwo_unit;
12009 struct attribute *attr;
12011 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
12014 complaint (&symfile_complaints,
12015 _("Dwarf Error: debug entry at offset 0x%x is missing"
12016 " its dwo_id [in module %s]"),
12017 to_underlying (sect_off), dwo_file->dwo_name);
12021 dwo_unit->dwo_file = dwo_file;
12022 dwo_unit->signature = DW_UNSND (attr);
12023 dwo_unit->section = section;
12024 dwo_unit->sect_off = sect_off;
12025 dwo_unit->length = cu->per_cu->length;
12027 if (dwarf_read_debug)
12028 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, dwo_id %s\n",
12029 to_underlying (sect_off),
12030 hex_string (dwo_unit->signature));
12033 /* Create the dwo_units for the CUs in a DWO_FILE.
12034 Note: This function processes DWO files only, not DWP files. */
12037 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12038 struct dwo_file &dwo_file, dwarf2_section_info §ion,
12041 struct objfile *objfile = dwarf2_per_objfile->objfile;
12042 const gdb_byte *info_ptr, *end_ptr;
12044 dwarf2_read_section (objfile, §ion);
12045 info_ptr = section.buffer;
12047 if (info_ptr == NULL)
12050 if (dwarf_read_debug)
12052 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
12053 get_section_name (§ion),
12054 get_section_file_name (§ion));
12057 end_ptr = info_ptr + section.size;
12058 while (info_ptr < end_ptr)
12060 struct dwarf2_per_cu_data per_cu;
12061 struct create_dwo_cu_data create_dwo_cu_data;
12062 struct dwo_unit *dwo_unit;
12064 sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
12066 memset (&create_dwo_cu_data.dwo_unit, 0,
12067 sizeof (create_dwo_cu_data.dwo_unit));
12068 memset (&per_cu, 0, sizeof (per_cu));
12069 per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
12070 per_cu.is_debug_types = 0;
12071 per_cu.sect_off = sect_offset (info_ptr - section.buffer);
12072 per_cu.section = §ion;
12073 create_dwo_cu_data.dwo_file = &dwo_file;
12075 init_cutu_and_read_dies_no_follow (
12076 &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
12077 info_ptr += per_cu.length;
12079 // If the unit could not be parsed, skip it.
12080 if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
12083 if (cus_htab == NULL)
12084 cus_htab = allocate_dwo_unit_table (objfile);
12086 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12087 *dwo_unit = create_dwo_cu_data.dwo_unit;
12088 slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
12089 gdb_assert (slot != NULL);
12092 const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
12093 sect_offset dup_sect_off = dup_cu->sect_off;
12095 complaint (&symfile_complaints,
12096 _("debug cu entry at offset 0x%x is duplicate to"
12097 " the entry at offset 0x%x, signature %s"),
12098 to_underlying (sect_off), to_underlying (dup_sect_off),
12099 hex_string (dwo_unit->signature));
12101 *slot = (void *)dwo_unit;
12105 /* DWP file .debug_{cu,tu}_index section format:
12106 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
12110 Both index sections have the same format, and serve to map a 64-bit
12111 signature to a set of section numbers. Each section begins with a header,
12112 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
12113 indexes, and a pool of 32-bit section numbers. The index sections will be
12114 aligned at 8-byte boundaries in the file.
12116 The index section header consists of:
12118 V, 32 bit version number
12120 N, 32 bit number of compilation units or type units in the index
12121 M, 32 bit number of slots in the hash table
12123 Numbers are recorded using the byte order of the application binary.
12125 The hash table begins at offset 16 in the section, and consists of an array
12126 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
12127 order of the application binary). Unused slots in the hash table are 0.
12128 (We rely on the extreme unlikeliness of a signature being exactly 0.)
12130 The parallel table begins immediately after the hash table
12131 (at offset 16 + 8 * M from the beginning of the section), and consists of an
12132 array of 32-bit indexes (using the byte order of the application binary),
12133 corresponding 1-1 with slots in the hash table. Each entry in the parallel
12134 table contains a 32-bit index into the pool of section numbers. For unused
12135 hash table slots, the corresponding entry in the parallel table will be 0.
12137 The pool of section numbers begins immediately following the hash table
12138 (at offset 16 + 12 * M from the beginning of the section). The pool of
12139 section numbers consists of an array of 32-bit words (using the byte order
12140 of the application binary). Each item in the array is indexed starting
12141 from 0. The hash table entry provides the index of the first section
12142 number in the set. Additional section numbers in the set follow, and the
12143 set is terminated by a 0 entry (section number 0 is not used in ELF).
12145 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12146 section must be the first entry in the set, and the .debug_abbrev.dwo must
12147 be the second entry. Other members of the set may follow in any order.
12153 DWP Version 2 combines all the .debug_info, etc. sections into one,
12154 and the entries in the index tables are now offsets into these sections.
12155 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12158 Index Section Contents:
12160 Hash Table of Signatures dwp_hash_table.hash_table
12161 Parallel Table of Indices dwp_hash_table.unit_table
12162 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12163 Table of Section Sizes dwp_hash_table.v2.sizes
12165 The index section header consists of:
12167 V, 32 bit version number
12168 L, 32 bit number of columns in the table of section offsets
12169 N, 32 bit number of compilation units or type units in the index
12170 M, 32 bit number of slots in the hash table
12172 Numbers are recorded using the byte order of the application binary.
12174 The hash table has the same format as version 1.
12175 The parallel table of indices has the same format as version 1,
12176 except that the entries are origin-1 indices into the table of sections
12177 offsets and the table of section sizes.
12179 The table of offsets begins immediately following the parallel table
12180 (at offset 16 + 12 * M from the beginning of the section). The table is
12181 a two-dimensional array of 32-bit words (using the byte order of the
12182 application binary), with L columns and N+1 rows, in row-major order.
12183 Each row in the array is indexed starting from 0. The first row provides
12184 a key to the remaining rows: each column in this row provides an identifier
12185 for a debug section, and the offsets in the same column of subsequent rows
12186 refer to that section. The section identifiers are:
12188 DW_SECT_INFO 1 .debug_info.dwo
12189 DW_SECT_TYPES 2 .debug_types.dwo
12190 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12191 DW_SECT_LINE 4 .debug_line.dwo
12192 DW_SECT_LOC 5 .debug_loc.dwo
12193 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12194 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12195 DW_SECT_MACRO 8 .debug_macro.dwo
12197 The offsets provided by the CU and TU index sections are the base offsets
12198 for the contributions made by each CU or TU to the corresponding section
12199 in the package file. Each CU and TU header contains an abbrev_offset
12200 field, used to find the abbreviations table for that CU or TU within the
12201 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12202 be interpreted as relative to the base offset given in the index section.
12203 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12204 should be interpreted as relative to the base offset for .debug_line.dwo,
12205 and offsets into other debug sections obtained from DWARF attributes should
12206 also be interpreted as relative to the corresponding base offset.
12208 The table of sizes begins immediately following the table of offsets.
12209 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12210 with L columns and N rows, in row-major order. Each row in the array is
12211 indexed starting from 1 (row 0 is shared by the two tables).
12215 Hash table lookup is handled the same in version 1 and 2:
12217 We assume that N and M will not exceed 2^32 - 1.
12218 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12220 Given a 64-bit compilation unit signature or a type signature S, an entry
12221 in the hash table is located as follows:
12223 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12224 the low-order k bits all set to 1.
12226 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12228 3) If the hash table entry at index H matches the signature, use that
12229 entry. If the hash table entry at index H is unused (all zeroes),
12230 terminate the search: the signature is not present in the table.
12232 4) Let H = (H + H') modulo M. Repeat at Step 3.
12234 Because M > N and H' and M are relatively prime, the search is guaranteed
12235 to stop at an unused slot or find the match. */
12237 /* Create a hash table to map DWO IDs to their CU/TU entry in
12238 .debug_{info,types}.dwo in DWP_FILE.
12239 Returns NULL if there isn't one.
12240 Note: This function processes DWP files only, not DWO files. */
12242 static struct dwp_hash_table *
12243 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12244 struct dwp_file *dwp_file, int is_debug_types)
12246 struct objfile *objfile = dwarf2_per_objfile->objfile;
12247 bfd *dbfd = dwp_file->dbfd;
12248 const gdb_byte *index_ptr, *index_end;
12249 struct dwarf2_section_info *index;
12250 uint32_t version, nr_columns, nr_units, nr_slots;
12251 struct dwp_hash_table *htab;
12253 if (is_debug_types)
12254 index = &dwp_file->sections.tu_index;
12256 index = &dwp_file->sections.cu_index;
12258 if (dwarf2_section_empty_p (index))
12260 dwarf2_read_section (objfile, index);
12262 index_ptr = index->buffer;
12263 index_end = index_ptr + index->size;
12265 version = read_4_bytes (dbfd, index_ptr);
12268 nr_columns = read_4_bytes (dbfd, index_ptr);
12272 nr_units = read_4_bytes (dbfd, index_ptr);
12274 nr_slots = read_4_bytes (dbfd, index_ptr);
12277 if (version != 1 && version != 2)
12279 error (_("Dwarf Error: unsupported DWP file version (%s)"
12280 " [in module %s]"),
12281 pulongest (version), dwp_file->name);
12283 if (nr_slots != (nr_slots & -nr_slots))
12285 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12286 " is not power of 2 [in module %s]"),
12287 pulongest (nr_slots), dwp_file->name);
12290 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12291 htab->version = version;
12292 htab->nr_columns = nr_columns;
12293 htab->nr_units = nr_units;
12294 htab->nr_slots = nr_slots;
12295 htab->hash_table = index_ptr;
12296 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12298 /* Exit early if the table is empty. */
12299 if (nr_slots == 0 || nr_units == 0
12300 || (version == 2 && nr_columns == 0))
12302 /* All must be zero. */
12303 if (nr_slots != 0 || nr_units != 0
12304 || (version == 2 && nr_columns != 0))
12306 complaint (&symfile_complaints,
12307 _("Empty DWP but nr_slots,nr_units,nr_columns not"
12308 " all zero [in modules %s]"),
12316 htab->section_pool.v1.indices =
12317 htab->unit_table + sizeof (uint32_t) * nr_slots;
12318 /* It's harder to decide whether the section is too small in v1.
12319 V1 is deprecated anyway so we punt. */
12323 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12324 int *ids = htab->section_pool.v2.section_ids;
12325 /* Reverse map for error checking. */
12326 int ids_seen[DW_SECT_MAX + 1];
12329 if (nr_columns < 2)
12331 error (_("Dwarf Error: bad DWP hash table, too few columns"
12332 " in section table [in module %s]"),
12335 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12337 error (_("Dwarf Error: bad DWP hash table, too many columns"
12338 " in section table [in module %s]"),
12341 memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
12342 memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
12343 for (i = 0; i < nr_columns; ++i)
12345 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12347 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12349 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12350 " in section table [in module %s]"),
12351 id, dwp_file->name);
12353 if (ids_seen[id] != -1)
12355 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12356 " id %d in section table [in module %s]"),
12357 id, dwp_file->name);
12362 /* Must have exactly one info or types section. */
12363 if (((ids_seen[DW_SECT_INFO] != -1)
12364 + (ids_seen[DW_SECT_TYPES] != -1))
12367 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12368 " DWO info/types section [in module %s]"),
12371 /* Must have an abbrev section. */
12372 if (ids_seen[DW_SECT_ABBREV] == -1)
12374 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12375 " section [in module %s]"),
12378 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12379 htab->section_pool.v2.sizes =
12380 htab->section_pool.v2.offsets + (sizeof (uint32_t)
12381 * nr_units * nr_columns);
12382 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12383 * nr_units * nr_columns))
12386 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12387 " [in module %s]"),
12395 /* Update SECTIONS with the data from SECTP.
12397 This function is like the other "locate" section routines that are
12398 passed to bfd_map_over_sections, but in this context the sections to
12399 read comes from the DWP V1 hash table, not the full ELF section table.
12401 The result is non-zero for success, or zero if an error was found. */
12404 locate_v1_virtual_dwo_sections (asection *sectp,
12405 struct virtual_v1_dwo_sections *sections)
12407 const struct dwop_section_names *names = &dwop_section_names;
12409 if (section_is_p (sectp->name, &names->abbrev_dwo))
12411 /* There can be only one. */
12412 if (sections->abbrev.s.section != NULL)
12414 sections->abbrev.s.section = sectp;
12415 sections->abbrev.size = bfd_get_section_size (sectp);
12417 else if (section_is_p (sectp->name, &names->info_dwo)
12418 || section_is_p (sectp->name, &names->types_dwo))
12420 /* There can be only one. */
12421 if (sections->info_or_types.s.section != NULL)
12423 sections->info_or_types.s.section = sectp;
12424 sections->info_or_types.size = bfd_get_section_size (sectp);
12426 else if (section_is_p (sectp->name, &names->line_dwo))
12428 /* There can be only one. */
12429 if (sections->line.s.section != NULL)
12431 sections->line.s.section = sectp;
12432 sections->line.size = bfd_get_section_size (sectp);
12434 else if (section_is_p (sectp->name, &names->loc_dwo))
12436 /* There can be only one. */
12437 if (sections->loc.s.section != NULL)
12439 sections->loc.s.section = sectp;
12440 sections->loc.size = bfd_get_section_size (sectp);
12442 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12444 /* There can be only one. */
12445 if (sections->macinfo.s.section != NULL)
12447 sections->macinfo.s.section = sectp;
12448 sections->macinfo.size = bfd_get_section_size (sectp);
12450 else if (section_is_p (sectp->name, &names->macro_dwo))
12452 /* There can be only one. */
12453 if (sections->macro.s.section != NULL)
12455 sections->macro.s.section = sectp;
12456 sections->macro.size = bfd_get_section_size (sectp);
12458 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12460 /* There can be only one. */
12461 if (sections->str_offsets.s.section != NULL)
12463 sections->str_offsets.s.section = sectp;
12464 sections->str_offsets.size = bfd_get_section_size (sectp);
12468 /* No other kind of section is valid. */
12475 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12476 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12477 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12478 This is for DWP version 1 files. */
12480 static struct dwo_unit *
12481 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12482 struct dwp_file *dwp_file,
12483 uint32_t unit_index,
12484 const char *comp_dir,
12485 ULONGEST signature, int is_debug_types)
12487 struct objfile *objfile = dwarf2_per_objfile->objfile;
12488 const struct dwp_hash_table *dwp_htab =
12489 is_debug_types ? dwp_file->tus : dwp_file->cus;
12490 bfd *dbfd = dwp_file->dbfd;
12491 const char *kind = is_debug_types ? "TU" : "CU";
12492 struct dwo_file *dwo_file;
12493 struct dwo_unit *dwo_unit;
12494 struct virtual_v1_dwo_sections sections;
12495 void **dwo_file_slot;
12498 gdb_assert (dwp_file->version == 1);
12500 if (dwarf_read_debug)
12502 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12504 pulongest (unit_index), hex_string (signature),
12508 /* Fetch the sections of this DWO unit.
12509 Put a limit on the number of sections we look for so that bad data
12510 doesn't cause us to loop forever. */
12512 #define MAX_NR_V1_DWO_SECTIONS \
12513 (1 /* .debug_info or .debug_types */ \
12514 + 1 /* .debug_abbrev */ \
12515 + 1 /* .debug_line */ \
12516 + 1 /* .debug_loc */ \
12517 + 1 /* .debug_str_offsets */ \
12518 + 1 /* .debug_macro or .debug_macinfo */ \
12519 + 1 /* trailing zero */)
12521 memset (§ions, 0, sizeof (sections));
12523 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12526 uint32_t section_nr =
12527 read_4_bytes (dbfd,
12528 dwp_htab->section_pool.v1.indices
12529 + (unit_index + i) * sizeof (uint32_t));
12531 if (section_nr == 0)
12533 if (section_nr >= dwp_file->num_sections)
12535 error (_("Dwarf Error: bad DWP hash table, section number too large"
12536 " [in module %s]"),
12540 sectp = dwp_file->elf_sections[section_nr];
12541 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
12543 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12544 " [in module %s]"),
12550 || dwarf2_section_empty_p (§ions.info_or_types)
12551 || dwarf2_section_empty_p (§ions.abbrev))
12553 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12554 " [in module %s]"),
12557 if (i == MAX_NR_V1_DWO_SECTIONS)
12559 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12560 " [in module %s]"),
12564 /* It's easier for the rest of the code if we fake a struct dwo_file and
12565 have dwo_unit "live" in that. At least for now.
12567 The DWP file can be made up of a random collection of CUs and TUs.
12568 However, for each CU + set of TUs that came from the same original DWO
12569 file, we can combine them back into a virtual DWO file to save space
12570 (fewer struct dwo_file objects to allocate). Remember that for really
12571 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12573 std::string virtual_dwo_name =
12574 string_printf ("virtual-dwo/%d-%d-%d-%d",
12575 get_section_id (§ions.abbrev),
12576 get_section_id (§ions.line),
12577 get_section_id (§ions.loc),
12578 get_section_id (§ions.str_offsets));
12579 /* Can we use an existing virtual DWO file? */
12580 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12581 virtual_dwo_name.c_str (),
12583 /* Create one if necessary. */
12584 if (*dwo_file_slot == NULL)
12586 if (dwarf_read_debug)
12588 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12589 virtual_dwo_name.c_str ());
12591 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12593 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12594 virtual_dwo_name.c_str (),
12595 virtual_dwo_name.size ());
12596 dwo_file->comp_dir = comp_dir;
12597 dwo_file->sections.abbrev = sections.abbrev;
12598 dwo_file->sections.line = sections.line;
12599 dwo_file->sections.loc = sections.loc;
12600 dwo_file->sections.macinfo = sections.macinfo;
12601 dwo_file->sections.macro = sections.macro;
12602 dwo_file->sections.str_offsets = sections.str_offsets;
12603 /* The "str" section is global to the entire DWP file. */
12604 dwo_file->sections.str = dwp_file->sections.str;
12605 /* The info or types section is assigned below to dwo_unit,
12606 there's no need to record it in dwo_file.
12607 Also, we can't simply record type sections in dwo_file because
12608 we record a pointer into the vector in dwo_unit. As we collect more
12609 types we'll grow the vector and eventually have to reallocate space
12610 for it, invalidating all copies of pointers into the previous
12612 *dwo_file_slot = dwo_file;
12616 if (dwarf_read_debug)
12618 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12619 virtual_dwo_name.c_str ());
12621 dwo_file = (struct dwo_file *) *dwo_file_slot;
12624 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12625 dwo_unit->dwo_file = dwo_file;
12626 dwo_unit->signature = signature;
12627 dwo_unit->section =
12628 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12629 *dwo_unit->section = sections.info_or_types;
12630 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12635 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12636 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12637 piece within that section used by a TU/CU, return a virtual section
12638 of just that piece. */
12640 static struct dwarf2_section_info
12641 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12642 struct dwarf2_section_info *section,
12643 bfd_size_type offset, bfd_size_type size)
12645 struct dwarf2_section_info result;
12648 gdb_assert (section != NULL);
12649 gdb_assert (!section->is_virtual);
12651 memset (&result, 0, sizeof (result));
12652 result.s.containing_section = section;
12653 result.is_virtual = 1;
12658 sectp = get_section_bfd_section (section);
12660 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12661 bounds of the real section. This is a pretty-rare event, so just
12662 flag an error (easier) instead of a warning and trying to cope. */
12664 || offset + size > bfd_get_section_size (sectp))
12666 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12667 " in section %s [in module %s]"),
12668 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12669 objfile_name (dwarf2_per_objfile->objfile));
12672 result.virtual_offset = offset;
12673 result.size = size;
12677 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12678 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12679 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12680 This is for DWP version 2 files. */
12682 static struct dwo_unit *
12683 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12684 struct dwp_file *dwp_file,
12685 uint32_t unit_index,
12686 const char *comp_dir,
12687 ULONGEST signature, int is_debug_types)
12689 struct objfile *objfile = dwarf2_per_objfile->objfile;
12690 const struct dwp_hash_table *dwp_htab =
12691 is_debug_types ? dwp_file->tus : dwp_file->cus;
12692 bfd *dbfd = dwp_file->dbfd;
12693 const char *kind = is_debug_types ? "TU" : "CU";
12694 struct dwo_file *dwo_file;
12695 struct dwo_unit *dwo_unit;
12696 struct virtual_v2_dwo_sections sections;
12697 void **dwo_file_slot;
12700 gdb_assert (dwp_file->version == 2);
12702 if (dwarf_read_debug)
12704 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12706 pulongest (unit_index), hex_string (signature),
12710 /* Fetch the section offsets of this DWO unit. */
12712 memset (§ions, 0, sizeof (sections));
12714 for (i = 0; i < dwp_htab->nr_columns; ++i)
12716 uint32_t offset = read_4_bytes (dbfd,
12717 dwp_htab->section_pool.v2.offsets
12718 + (((unit_index - 1) * dwp_htab->nr_columns
12720 * sizeof (uint32_t)));
12721 uint32_t size = read_4_bytes (dbfd,
12722 dwp_htab->section_pool.v2.sizes
12723 + (((unit_index - 1) * dwp_htab->nr_columns
12725 * sizeof (uint32_t)));
12727 switch (dwp_htab->section_pool.v2.section_ids[i])
12730 case DW_SECT_TYPES:
12731 sections.info_or_types_offset = offset;
12732 sections.info_or_types_size = size;
12734 case DW_SECT_ABBREV:
12735 sections.abbrev_offset = offset;
12736 sections.abbrev_size = size;
12739 sections.line_offset = offset;
12740 sections.line_size = size;
12743 sections.loc_offset = offset;
12744 sections.loc_size = size;
12746 case DW_SECT_STR_OFFSETS:
12747 sections.str_offsets_offset = offset;
12748 sections.str_offsets_size = size;
12750 case DW_SECT_MACINFO:
12751 sections.macinfo_offset = offset;
12752 sections.macinfo_size = size;
12754 case DW_SECT_MACRO:
12755 sections.macro_offset = offset;
12756 sections.macro_size = size;
12761 /* It's easier for the rest of the code if we fake a struct dwo_file and
12762 have dwo_unit "live" in that. At least for now.
12764 The DWP file can be made up of a random collection of CUs and TUs.
12765 However, for each CU + set of TUs that came from the same original DWO
12766 file, we can combine them back into a virtual DWO file to save space
12767 (fewer struct dwo_file objects to allocate). Remember that for really
12768 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12770 std::string virtual_dwo_name =
12771 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12772 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12773 (long) (sections.line_size ? sections.line_offset : 0),
12774 (long) (sections.loc_size ? sections.loc_offset : 0),
12775 (long) (sections.str_offsets_size
12776 ? sections.str_offsets_offset : 0));
12777 /* Can we use an existing virtual DWO file? */
12778 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12779 virtual_dwo_name.c_str (),
12781 /* Create one if necessary. */
12782 if (*dwo_file_slot == NULL)
12784 if (dwarf_read_debug)
12786 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12787 virtual_dwo_name.c_str ());
12789 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12791 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12792 virtual_dwo_name.c_str (),
12793 virtual_dwo_name.size ());
12794 dwo_file->comp_dir = comp_dir;
12795 dwo_file->sections.abbrev =
12796 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12797 sections.abbrev_offset, sections.abbrev_size);
12798 dwo_file->sections.line =
12799 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12800 sections.line_offset, sections.line_size);
12801 dwo_file->sections.loc =
12802 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12803 sections.loc_offset, sections.loc_size);
12804 dwo_file->sections.macinfo =
12805 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12806 sections.macinfo_offset, sections.macinfo_size);
12807 dwo_file->sections.macro =
12808 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12809 sections.macro_offset, sections.macro_size);
12810 dwo_file->sections.str_offsets =
12811 create_dwp_v2_section (dwarf2_per_objfile,
12812 &dwp_file->sections.str_offsets,
12813 sections.str_offsets_offset,
12814 sections.str_offsets_size);
12815 /* The "str" section is global to the entire DWP file. */
12816 dwo_file->sections.str = dwp_file->sections.str;
12817 /* The info or types section is assigned below to dwo_unit,
12818 there's no need to record it in dwo_file.
12819 Also, we can't simply record type sections in dwo_file because
12820 we record a pointer into the vector in dwo_unit. As we collect more
12821 types we'll grow the vector and eventually have to reallocate space
12822 for it, invalidating all copies of pointers into the previous
12824 *dwo_file_slot = dwo_file;
12828 if (dwarf_read_debug)
12830 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12831 virtual_dwo_name.c_str ());
12833 dwo_file = (struct dwo_file *) *dwo_file_slot;
12836 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12837 dwo_unit->dwo_file = dwo_file;
12838 dwo_unit->signature = signature;
12839 dwo_unit->section =
12840 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12841 *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12843 ? &dwp_file->sections.types
12844 : &dwp_file->sections.info,
12845 sections.info_or_types_offset,
12846 sections.info_or_types_size);
12847 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12852 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12853 Returns NULL if the signature isn't found. */
12855 static struct dwo_unit *
12856 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12857 struct dwp_file *dwp_file, const char *comp_dir,
12858 ULONGEST signature, int is_debug_types)
12860 const struct dwp_hash_table *dwp_htab =
12861 is_debug_types ? dwp_file->tus : dwp_file->cus;
12862 bfd *dbfd = dwp_file->dbfd;
12863 uint32_t mask = dwp_htab->nr_slots - 1;
12864 uint32_t hash = signature & mask;
12865 uint32_t hash2 = ((signature >> 32) & mask) | 1;
12868 struct dwo_unit find_dwo_cu;
12870 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12871 find_dwo_cu.signature = signature;
12872 slot = htab_find_slot (is_debug_types
12873 ? dwp_file->loaded_tus
12874 : dwp_file->loaded_cus,
12875 &find_dwo_cu, INSERT);
12878 return (struct dwo_unit *) *slot;
12880 /* Use a for loop so that we don't loop forever on bad debug info. */
12881 for (i = 0; i < dwp_htab->nr_slots; ++i)
12883 ULONGEST signature_in_table;
12885 signature_in_table =
12886 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12887 if (signature_in_table == signature)
12889 uint32_t unit_index =
12890 read_4_bytes (dbfd,
12891 dwp_htab->unit_table + hash * sizeof (uint32_t));
12893 if (dwp_file->version == 1)
12895 *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12896 dwp_file, unit_index,
12897 comp_dir, signature,
12902 *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12903 dwp_file, unit_index,
12904 comp_dir, signature,
12907 return (struct dwo_unit *) *slot;
12909 if (signature_in_table == 0)
12911 hash = (hash + hash2) & mask;
12914 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12915 " [in module %s]"),
12919 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12920 Open the file specified by FILE_NAME and hand it off to BFD for
12921 preliminary analysis. Return a newly initialized bfd *, which
12922 includes a canonicalized copy of FILE_NAME.
12923 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12924 SEARCH_CWD is true if the current directory is to be searched.
12925 It will be searched before debug-file-directory.
12926 If successful, the file is added to the bfd include table of the
12927 objfile's bfd (see gdb_bfd_record_inclusion).
12928 If unable to find/open the file, return NULL.
12929 NOTE: This function is derived from symfile_bfd_open. */
12931 static gdb_bfd_ref_ptr
12932 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12933 const char *file_name, int is_dwp, int search_cwd)
12936 char *absolute_name;
12937 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12938 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12939 to debug_file_directory. */
12941 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12945 if (*debug_file_directory != '\0')
12946 search_path = concat (".", dirname_separator_string,
12947 debug_file_directory, (char *) NULL);
12949 search_path = xstrdup (".");
12952 search_path = xstrdup (debug_file_directory);
12954 flags = OPF_RETURN_REALPATH;
12956 flags |= OPF_SEARCH_IN_PATH;
12957 desc = openp (search_path, flags, file_name,
12958 O_RDONLY | O_BINARY, &absolute_name);
12959 xfree (search_path);
12963 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name, gnutarget, desc));
12964 xfree (absolute_name);
12965 if (sym_bfd == NULL)
12967 bfd_set_cacheable (sym_bfd.get (), 1);
12969 if (!bfd_check_format (sym_bfd.get (), bfd_object))
12972 /* Success. Record the bfd as having been included by the objfile's bfd.
12973 This is important because things like demangled_names_hash lives in the
12974 objfile's per_bfd space and may have references to things like symbol
12975 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12976 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12981 /* Try to open DWO file FILE_NAME.
12982 COMP_DIR is the DW_AT_comp_dir attribute.
12983 The result is the bfd handle of the file.
12984 If there is a problem finding or opening the file, return NULL.
12985 Upon success, the canonicalized path of the file is stored in the bfd,
12986 same as symfile_bfd_open. */
12988 static gdb_bfd_ref_ptr
12989 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12990 const char *file_name, const char *comp_dir)
12992 if (IS_ABSOLUTE_PATH (file_name))
12993 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12994 0 /*is_dwp*/, 0 /*search_cwd*/);
12996 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12998 if (comp_dir != NULL)
13000 char *path_to_try = concat (comp_dir, SLASH_STRING,
13001 file_name, (char *) NULL);
13003 /* NOTE: If comp_dir is a relative path, this will also try the
13004 search path, which seems useful. */
13005 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
13008 1 /*search_cwd*/));
13009 xfree (path_to_try);
13014 /* That didn't work, try debug-file-directory, which, despite its name,
13015 is a list of paths. */
13017 if (*debug_file_directory == '\0')
13020 return try_open_dwop_file (dwarf2_per_objfile, file_name,
13021 0 /*is_dwp*/, 1 /*search_cwd*/);
13024 /* This function is mapped across the sections and remembers the offset and
13025 size of each of the DWO debugging sections we are interested in. */
13028 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
13030 struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
13031 const struct dwop_section_names *names = &dwop_section_names;
13033 if (section_is_p (sectp->name, &names->abbrev_dwo))
13035 dwo_sections->abbrev.s.section = sectp;
13036 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
13038 else if (section_is_p (sectp->name, &names->info_dwo))
13040 dwo_sections->info.s.section = sectp;
13041 dwo_sections->info.size = bfd_get_section_size (sectp);
13043 else if (section_is_p (sectp->name, &names->line_dwo))
13045 dwo_sections->line.s.section = sectp;
13046 dwo_sections->line.size = bfd_get_section_size (sectp);
13048 else if (section_is_p (sectp->name, &names->loc_dwo))
13050 dwo_sections->loc.s.section = sectp;
13051 dwo_sections->loc.size = bfd_get_section_size (sectp);
13053 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13055 dwo_sections->macinfo.s.section = sectp;
13056 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
13058 else if (section_is_p (sectp->name, &names->macro_dwo))
13060 dwo_sections->macro.s.section = sectp;
13061 dwo_sections->macro.size = bfd_get_section_size (sectp);
13063 else if (section_is_p (sectp->name, &names->str_dwo))
13065 dwo_sections->str.s.section = sectp;
13066 dwo_sections->str.size = bfd_get_section_size (sectp);
13068 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13070 dwo_sections->str_offsets.s.section = sectp;
13071 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
13073 else if (section_is_p (sectp->name, &names->types_dwo))
13075 struct dwarf2_section_info type_section;
13077 memset (&type_section, 0, sizeof (type_section));
13078 type_section.s.section = sectp;
13079 type_section.size = bfd_get_section_size (sectp);
13080 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
13085 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
13086 by PER_CU. This is for the non-DWP case.
13087 The result is NULL if DWO_NAME can't be found. */
13089 static struct dwo_file *
13090 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
13091 const char *dwo_name, const char *comp_dir)
13093 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
13094 struct objfile *objfile = dwarf2_per_objfile->objfile;
13095 struct dwo_file *dwo_file;
13096 struct cleanup *cleanups;
13098 gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
13101 if (dwarf_read_debug)
13102 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
13105 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
13106 dwo_file->dwo_name = dwo_name;
13107 dwo_file->comp_dir = comp_dir;
13108 dwo_file->dbfd = dbfd.release ();
13110 free_dwo_file_cleanup_data *cleanup_data = XNEW (free_dwo_file_cleanup_data);
13111 cleanup_data->dwo_file = dwo_file;
13112 cleanup_data->dwarf2_per_objfile = dwarf2_per_objfile;
13114 cleanups = make_cleanup (free_dwo_file_cleanup, cleanup_data);
13116 bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
13117 &dwo_file->sections);
13119 create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
13122 create_debug_types_hash_table (dwarf2_per_objfile, dwo_file,
13123 dwo_file->sections.types, dwo_file->tus);
13125 discard_cleanups (cleanups);
13127 if (dwarf_read_debug)
13128 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
13133 /* This function is mapped across the sections and remembers the offset and
13134 size of each of the DWP debugging sections common to version 1 and 2 that
13135 we are interested in. */
13138 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
13139 void *dwp_file_ptr)
13141 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13142 const struct dwop_section_names *names = &dwop_section_names;
13143 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13145 /* Record the ELF section number for later lookup: this is what the
13146 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13147 gdb_assert (elf_section_nr < dwp_file->num_sections);
13148 dwp_file->elf_sections[elf_section_nr] = sectp;
13150 /* Look for specific sections that we need. */
13151 if (section_is_p (sectp->name, &names->str_dwo))
13153 dwp_file->sections.str.s.section = sectp;
13154 dwp_file->sections.str.size = bfd_get_section_size (sectp);
13156 else if (section_is_p (sectp->name, &names->cu_index))
13158 dwp_file->sections.cu_index.s.section = sectp;
13159 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13161 else if (section_is_p (sectp->name, &names->tu_index))
13163 dwp_file->sections.tu_index.s.section = sectp;
13164 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13168 /* This function is mapped across the sections and remembers the offset and
13169 size of each of the DWP version 2 debugging sections that we are interested
13170 in. This is split into a separate function because we don't know if we
13171 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13174 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13176 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13177 const struct dwop_section_names *names = &dwop_section_names;
13178 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13180 /* Record the ELF section number for later lookup: this is what the
13181 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13182 gdb_assert (elf_section_nr < dwp_file->num_sections);
13183 dwp_file->elf_sections[elf_section_nr] = sectp;
13185 /* Look for specific sections that we need. */
13186 if (section_is_p (sectp->name, &names->abbrev_dwo))
13188 dwp_file->sections.abbrev.s.section = sectp;
13189 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13191 else if (section_is_p (sectp->name, &names->info_dwo))
13193 dwp_file->sections.info.s.section = sectp;
13194 dwp_file->sections.info.size = bfd_get_section_size (sectp);
13196 else if (section_is_p (sectp->name, &names->line_dwo))
13198 dwp_file->sections.line.s.section = sectp;
13199 dwp_file->sections.line.size = bfd_get_section_size (sectp);
13201 else if (section_is_p (sectp->name, &names->loc_dwo))
13203 dwp_file->sections.loc.s.section = sectp;
13204 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13206 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13208 dwp_file->sections.macinfo.s.section = sectp;
13209 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13211 else if (section_is_p (sectp->name, &names->macro_dwo))
13213 dwp_file->sections.macro.s.section = sectp;
13214 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13216 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13218 dwp_file->sections.str_offsets.s.section = sectp;
13219 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13221 else if (section_is_p (sectp->name, &names->types_dwo))
13223 dwp_file->sections.types.s.section = sectp;
13224 dwp_file->sections.types.size = bfd_get_section_size (sectp);
13228 /* Hash function for dwp_file loaded CUs/TUs. */
13231 hash_dwp_loaded_cutus (const void *item)
13233 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13235 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13236 return dwo_unit->signature;
13239 /* Equality function for dwp_file loaded CUs/TUs. */
13242 eq_dwp_loaded_cutus (const void *a, const void *b)
13244 const struct dwo_unit *dua = (const struct dwo_unit *) a;
13245 const struct dwo_unit *dub = (const struct dwo_unit *) b;
13247 return dua->signature == dub->signature;
13250 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13253 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13255 return htab_create_alloc_ex (3,
13256 hash_dwp_loaded_cutus,
13257 eq_dwp_loaded_cutus,
13259 &objfile->objfile_obstack,
13260 hashtab_obstack_allocate,
13261 dummy_obstack_deallocate);
13264 /* Try to open DWP file FILE_NAME.
13265 The result is the bfd handle of the file.
13266 If there is a problem finding or opening the file, return NULL.
13267 Upon success, the canonicalized path of the file is stored in the bfd,
13268 same as symfile_bfd_open. */
13270 static gdb_bfd_ref_ptr
13271 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13272 const char *file_name)
13274 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13276 1 /*search_cwd*/));
13280 /* Work around upstream bug 15652.
13281 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13282 [Whether that's a "bug" is debatable, but it is getting in our way.]
13283 We have no real idea where the dwp file is, because gdb's realpath-ing
13284 of the executable's path may have discarded the needed info.
13285 [IWBN if the dwp file name was recorded in the executable, akin to
13286 .gnu_debuglink, but that doesn't exist yet.]
13287 Strip the directory from FILE_NAME and search again. */
13288 if (*debug_file_directory != '\0')
13290 /* Don't implicitly search the current directory here.
13291 If the user wants to search "." to handle this case,
13292 it must be added to debug-file-directory. */
13293 return try_open_dwop_file (dwarf2_per_objfile,
13294 lbasename (file_name), 1 /*is_dwp*/,
13301 /* Initialize the use of the DWP file for the current objfile.
13302 By convention the name of the DWP file is ${objfile}.dwp.
13303 The result is NULL if it can't be found. */
13305 static struct dwp_file *
13306 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13308 struct objfile *objfile = dwarf2_per_objfile->objfile;
13309 struct dwp_file *dwp_file;
13311 /* Try to find first .dwp for the binary file before any symbolic links
13314 /* If the objfile is a debug file, find the name of the real binary
13315 file and get the name of dwp file from there. */
13316 std::string dwp_name;
13317 if (objfile->separate_debug_objfile_backlink != NULL)
13319 struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13320 const char *backlink_basename = lbasename (backlink->original_name);
13322 dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13325 dwp_name = objfile->original_name;
13327 dwp_name += ".dwp";
13329 gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13331 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13333 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13334 dwp_name = objfile_name (objfile);
13335 dwp_name += ".dwp";
13336 dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13341 if (dwarf_read_debug)
13342 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13345 dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file);
13346 dwp_file->name = bfd_get_filename (dbfd.get ());
13347 dwp_file->dbfd = dbfd.release ();
13349 /* +1: section 0 is unused */
13350 dwp_file->num_sections = bfd_count_sections (dwp_file->dbfd) + 1;
13351 dwp_file->elf_sections =
13352 OBSTACK_CALLOC (&objfile->objfile_obstack,
13353 dwp_file->num_sections, asection *);
13355 bfd_map_over_sections (dwp_file->dbfd, dwarf2_locate_common_dwp_sections,
13358 dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file, 0);
13360 dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file, 1);
13362 /* The DWP file version is stored in the hash table. Oh well. */
13363 if (dwp_file->cus && dwp_file->tus
13364 && dwp_file->cus->version != dwp_file->tus->version)
13366 /* Technically speaking, we should try to limp along, but this is
13367 pretty bizarre. We use pulongest here because that's the established
13368 portability solution (e.g, we cannot use %u for uint32_t). */
13369 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13370 " TU version %s [in DWP file %s]"),
13371 pulongest (dwp_file->cus->version),
13372 pulongest (dwp_file->tus->version), dwp_name.c_str ());
13376 dwp_file->version = dwp_file->cus->version;
13377 else if (dwp_file->tus)
13378 dwp_file->version = dwp_file->tus->version;
13380 dwp_file->version = 2;
13382 if (dwp_file->version == 2)
13383 bfd_map_over_sections (dwp_file->dbfd, dwarf2_locate_v2_dwp_sections,
13386 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13387 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13389 if (dwarf_read_debug)
13391 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13392 fprintf_unfiltered (gdb_stdlog,
13393 " %s CUs, %s TUs\n",
13394 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13395 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13401 /* Wrapper around open_and_init_dwp_file, only open it once. */
13403 static struct dwp_file *
13404 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13406 if (! dwarf2_per_objfile->dwp_checked)
13408 dwarf2_per_objfile->dwp_file
13409 = open_and_init_dwp_file (dwarf2_per_objfile);
13410 dwarf2_per_objfile->dwp_checked = 1;
13412 return dwarf2_per_objfile->dwp_file;
13415 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13416 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13417 or in the DWP file for the objfile, referenced by THIS_UNIT.
13418 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13419 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13421 This is called, for example, when wanting to read a variable with a
13422 complex location. Therefore we don't want to do file i/o for every call.
13423 Therefore we don't want to look for a DWO file on every call.
13424 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13425 then we check if we've already seen DWO_NAME, and only THEN do we check
13428 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13429 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13431 static struct dwo_unit *
13432 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13433 const char *dwo_name, const char *comp_dir,
13434 ULONGEST signature, int is_debug_types)
13436 struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13437 struct objfile *objfile = dwarf2_per_objfile->objfile;
13438 const char *kind = is_debug_types ? "TU" : "CU";
13439 void **dwo_file_slot;
13440 struct dwo_file *dwo_file;
13441 struct dwp_file *dwp_file;
13443 /* First see if there's a DWP file.
13444 If we have a DWP file but didn't find the DWO inside it, don't
13445 look for the original DWO file. It makes gdb behave differently
13446 depending on whether one is debugging in the build tree. */
13448 dwp_file = get_dwp_file (dwarf2_per_objfile);
13449 if (dwp_file != NULL)
13451 const struct dwp_hash_table *dwp_htab =
13452 is_debug_types ? dwp_file->tus : dwp_file->cus;
13454 if (dwp_htab != NULL)
13456 struct dwo_unit *dwo_cutu =
13457 lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13458 signature, is_debug_types);
13460 if (dwo_cutu != NULL)
13462 if (dwarf_read_debug)
13464 fprintf_unfiltered (gdb_stdlog,
13465 "Virtual DWO %s %s found: @%s\n",
13466 kind, hex_string (signature),
13467 host_address_to_string (dwo_cutu));
13475 /* No DWP file, look for the DWO file. */
13477 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13478 dwo_name, comp_dir);
13479 if (*dwo_file_slot == NULL)
13481 /* Read in the file and build a table of the CUs/TUs it contains. */
13482 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13484 /* NOTE: This will be NULL if unable to open the file. */
13485 dwo_file = (struct dwo_file *) *dwo_file_slot;
13487 if (dwo_file != NULL)
13489 struct dwo_unit *dwo_cutu = NULL;
13491 if (is_debug_types && dwo_file->tus)
13493 struct dwo_unit find_dwo_cutu;
13495 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13496 find_dwo_cutu.signature = signature;
13498 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13500 else if (!is_debug_types && dwo_file->cus)
13502 struct dwo_unit find_dwo_cutu;
13504 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13505 find_dwo_cutu.signature = signature;
13506 dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13510 if (dwo_cutu != NULL)
13512 if (dwarf_read_debug)
13514 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13515 kind, dwo_name, hex_string (signature),
13516 host_address_to_string (dwo_cutu));
13523 /* We didn't find it. This could mean a dwo_id mismatch, or
13524 someone deleted the DWO/DWP file, or the search path isn't set up
13525 correctly to find the file. */
13527 if (dwarf_read_debug)
13529 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13530 kind, dwo_name, hex_string (signature));
13533 /* This is a warning and not a complaint because it can be caused by
13534 pilot error (e.g., user accidentally deleting the DWO). */
13536 /* Print the name of the DWP file if we looked there, helps the user
13537 better diagnose the problem. */
13538 std::string dwp_text;
13540 if (dwp_file != NULL)
13541 dwp_text = string_printf (" [in DWP file %s]",
13542 lbasename (dwp_file->name));
13544 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
13545 " [in module %s]"),
13546 kind, dwo_name, hex_string (signature),
13548 this_unit->is_debug_types ? "TU" : "CU",
13549 to_underlying (this_unit->sect_off), objfile_name (objfile));
13554 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13555 See lookup_dwo_cutu_unit for details. */
13557 static struct dwo_unit *
13558 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13559 const char *dwo_name, const char *comp_dir,
13560 ULONGEST signature)
13562 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13565 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13566 See lookup_dwo_cutu_unit for details. */
13568 static struct dwo_unit *
13569 lookup_dwo_type_unit (struct signatured_type *this_tu,
13570 const char *dwo_name, const char *comp_dir)
13572 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13575 /* Traversal function for queue_and_load_all_dwo_tus. */
13578 queue_and_load_dwo_tu (void **slot, void *info)
13580 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13581 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13582 ULONGEST signature = dwo_unit->signature;
13583 struct signatured_type *sig_type =
13584 lookup_dwo_signatured_type (per_cu->cu, signature);
13586 if (sig_type != NULL)
13588 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13590 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13591 a real dependency of PER_CU on SIG_TYPE. That is detected later
13592 while processing PER_CU. */
13593 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13594 load_full_type_unit (sig_cu);
13595 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13601 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13602 The DWO may have the only definition of the type, though it may not be
13603 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13604 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13607 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13609 struct dwo_unit *dwo_unit;
13610 struct dwo_file *dwo_file;
13612 gdb_assert (!per_cu->is_debug_types);
13613 gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13614 gdb_assert (per_cu->cu != NULL);
13616 dwo_unit = per_cu->cu->dwo_unit;
13617 gdb_assert (dwo_unit != NULL);
13619 dwo_file = dwo_unit->dwo_file;
13620 if (dwo_file->tus != NULL)
13621 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13624 /* Free all resources associated with DWO_FILE.
13625 Close the DWO file and munmap the sections.
13626 All memory should be on the objfile obstack. */
13629 free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
13632 /* Note: dbfd is NULL for virtual DWO files. */
13633 gdb_bfd_unref (dwo_file->dbfd);
13635 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13638 /* Wrapper for free_dwo_file for use in cleanups. */
13641 free_dwo_file_cleanup (void *arg)
13643 struct free_dwo_file_cleanup_data *data
13644 = (struct free_dwo_file_cleanup_data *) arg;
13645 struct objfile *objfile = data->dwarf2_per_objfile->objfile;
13647 free_dwo_file (data->dwo_file, objfile);
13652 /* Traversal function for free_dwo_files. */
13655 free_dwo_file_from_slot (void **slot, void *info)
13657 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13658 struct objfile *objfile = (struct objfile *) info;
13660 free_dwo_file (dwo_file, objfile);
13665 /* Free all resources associated with DWO_FILES. */
13668 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13670 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13673 /* Read in various DIEs. */
13675 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13676 Inherit only the children of the DW_AT_abstract_origin DIE not being
13677 already referenced by DW_AT_abstract_origin from the children of the
13681 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13683 struct die_info *child_die;
13684 sect_offset *offsetp;
13685 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13686 struct die_info *origin_die;
13687 /* Iterator of the ORIGIN_DIE children. */
13688 struct die_info *origin_child_die;
13689 struct attribute *attr;
13690 struct dwarf2_cu *origin_cu;
13691 struct pending **origin_previous_list_in_scope;
13693 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13697 /* Note that following die references may follow to a die in a
13701 origin_die = follow_die_ref (die, attr, &origin_cu);
13703 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13705 origin_previous_list_in_scope = origin_cu->list_in_scope;
13706 origin_cu->list_in_scope = cu->list_in_scope;
13708 if (die->tag != origin_die->tag
13709 && !(die->tag == DW_TAG_inlined_subroutine
13710 && origin_die->tag == DW_TAG_subprogram))
13711 complaint (&symfile_complaints,
13712 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
13713 to_underlying (die->sect_off),
13714 to_underlying (origin_die->sect_off));
13716 std::vector<sect_offset> offsets;
13718 for (child_die = die->child;
13719 child_die && child_die->tag;
13720 child_die = sibling_die (child_die))
13722 struct die_info *child_origin_die;
13723 struct dwarf2_cu *child_origin_cu;
13725 /* We are trying to process concrete instance entries:
13726 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13727 it's not relevant to our analysis here. i.e. detecting DIEs that are
13728 present in the abstract instance but not referenced in the concrete
13730 if (child_die->tag == DW_TAG_call_site
13731 || child_die->tag == DW_TAG_GNU_call_site)
13734 /* For each CHILD_DIE, find the corresponding child of
13735 ORIGIN_DIE. If there is more than one layer of
13736 DW_AT_abstract_origin, follow them all; there shouldn't be,
13737 but GCC versions at least through 4.4 generate this (GCC PR
13739 child_origin_die = child_die;
13740 child_origin_cu = cu;
13743 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13747 child_origin_die = follow_die_ref (child_origin_die, attr,
13751 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13752 counterpart may exist. */
13753 if (child_origin_die != child_die)
13755 if (child_die->tag != child_origin_die->tag
13756 && !(child_die->tag == DW_TAG_inlined_subroutine
13757 && child_origin_die->tag == DW_TAG_subprogram))
13758 complaint (&symfile_complaints,
13759 _("Child DIE 0x%x and its abstract origin 0x%x have "
13761 to_underlying (child_die->sect_off),
13762 to_underlying (child_origin_die->sect_off));
13763 if (child_origin_die->parent != origin_die)
13764 complaint (&symfile_complaints,
13765 _("Child DIE 0x%x and its abstract origin 0x%x have "
13766 "different parents"),
13767 to_underlying (child_die->sect_off),
13768 to_underlying (child_origin_die->sect_off));
13770 offsets.push_back (child_origin_die->sect_off);
13773 std::sort (offsets.begin (), offsets.end ());
13774 sect_offset *offsets_end = offsets.data () + offsets.size ();
13775 for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13776 if (offsetp[-1] == *offsetp)
13777 complaint (&symfile_complaints,
13778 _("Multiple children of DIE 0x%x refer "
13779 "to DIE 0x%x as their abstract origin"),
13780 to_underlying (die->sect_off), to_underlying (*offsetp));
13782 offsetp = offsets.data ();
13783 origin_child_die = origin_die->child;
13784 while (origin_child_die && origin_child_die->tag)
13786 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13787 while (offsetp < offsets_end
13788 && *offsetp < origin_child_die->sect_off)
13790 if (offsetp >= offsets_end
13791 || *offsetp > origin_child_die->sect_off)
13793 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13794 Check whether we're already processing ORIGIN_CHILD_DIE.
13795 This can happen with mutually referenced abstract_origins.
13797 if (!origin_child_die->in_process)
13798 process_die (origin_child_die, origin_cu);
13800 origin_child_die = sibling_die (origin_child_die);
13802 origin_cu->list_in_scope = origin_previous_list_in_scope;
13806 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13808 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13809 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13810 struct context_stack *newobj;
13813 struct die_info *child_die;
13814 struct attribute *attr, *call_line, *call_file;
13816 CORE_ADDR baseaddr;
13817 struct block *block;
13818 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13819 std::vector<struct symbol *> template_args;
13820 struct template_symbol *templ_func = NULL;
13824 /* If we do not have call site information, we can't show the
13825 caller of this inlined function. That's too confusing, so
13826 only use the scope for local variables. */
13827 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13828 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13829 if (call_line == NULL || call_file == NULL)
13831 read_lexical_block_scope (die, cu);
13836 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13838 name = dwarf2_name (die, cu);
13840 /* Ignore functions with missing or empty names. These are actually
13841 illegal according to the DWARF standard. */
13844 complaint (&symfile_complaints,
13845 _("missing name for subprogram DIE at %d"),
13846 to_underlying (die->sect_off));
13850 /* Ignore functions with missing or invalid low and high pc attributes. */
13851 if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13852 <= PC_BOUNDS_INVALID)
13854 attr = dwarf2_attr (die, DW_AT_external, cu);
13855 if (!attr || !DW_UNSND (attr))
13856 complaint (&symfile_complaints,
13857 _("cannot get low and high bounds "
13858 "for subprogram DIE at %d"),
13859 to_underlying (die->sect_off));
13863 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13864 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13866 /* If we have any template arguments, then we must allocate a
13867 different sort of symbol. */
13868 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13870 if (child_die->tag == DW_TAG_template_type_param
13871 || child_die->tag == DW_TAG_template_value_param)
13873 templ_func = allocate_template_symbol (objfile);
13874 templ_func->subclass = SYMBOL_TEMPLATE;
13879 newobj = push_context (0, lowpc);
13880 newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13881 (struct symbol *) templ_func);
13883 /* If there is a location expression for DW_AT_frame_base, record
13885 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13887 dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13889 /* If there is a location for the static link, record it. */
13890 newobj->static_link = NULL;
13891 attr = dwarf2_attr (die, DW_AT_static_link, cu);
13894 newobj->static_link
13895 = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13896 attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13899 cu->list_in_scope = &local_symbols;
13901 if (die->child != NULL)
13903 child_die = die->child;
13904 while (child_die && child_die->tag)
13906 if (child_die->tag == DW_TAG_template_type_param
13907 || child_die->tag == DW_TAG_template_value_param)
13909 struct symbol *arg = new_symbol (child_die, NULL, cu);
13912 template_args.push_back (arg);
13915 process_die (child_die, cu);
13916 child_die = sibling_die (child_die);
13920 inherit_abstract_dies (die, cu);
13922 /* If we have a DW_AT_specification, we might need to import using
13923 directives from the context of the specification DIE. See the
13924 comment in determine_prefix. */
13925 if (cu->language == language_cplus
13926 && dwarf2_attr (die, DW_AT_specification, cu))
13928 struct dwarf2_cu *spec_cu = cu;
13929 struct die_info *spec_die = die_specification (die, &spec_cu);
13933 child_die = spec_die->child;
13934 while (child_die && child_die->tag)
13936 if (child_die->tag == DW_TAG_imported_module)
13937 process_die (child_die, spec_cu);
13938 child_die = sibling_die (child_die);
13941 /* In some cases, GCC generates specification DIEs that
13942 themselves contain DW_AT_specification attributes. */
13943 spec_die = die_specification (spec_die, &spec_cu);
13947 newobj = pop_context ();
13948 /* Make a block for the local symbols within. */
13949 block = finish_block (newobj->name, &local_symbols, newobj->old_blocks,
13950 newobj->static_link, lowpc, highpc);
13952 /* For C++, set the block's scope. */
13953 if ((cu->language == language_cplus
13954 || cu->language == language_fortran
13955 || cu->language == language_d
13956 || cu->language == language_rust)
13957 && cu->processing_has_namespace_info)
13958 block_set_scope (block, determine_prefix (die, cu),
13959 &objfile->objfile_obstack);
13961 /* If we have address ranges, record them. */
13962 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13964 gdbarch_make_symbol_special (gdbarch, newobj->name, objfile);
13966 /* Attach template arguments to function. */
13967 if (!template_args.empty ())
13969 gdb_assert (templ_func != NULL);
13971 templ_func->n_template_arguments = template_args.size ();
13972 templ_func->template_arguments
13973 = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13974 templ_func->n_template_arguments);
13975 memcpy (templ_func->template_arguments,
13976 template_args.data (),
13977 (templ_func->n_template_arguments * sizeof (struct symbol *)));
13980 /* In C++, we can have functions nested inside functions (e.g., when
13981 a function declares a class that has methods). This means that
13982 when we finish processing a function scope, we may need to go
13983 back to building a containing block's symbol lists. */
13984 local_symbols = newobj->locals;
13985 local_using_directives = newobj->local_using_directives;
13987 /* If we've finished processing a top-level function, subsequent
13988 symbols go in the file symbol list. */
13989 if (outermost_context_p ())
13990 cu->list_in_scope = &file_symbols;
13993 /* Process all the DIES contained within a lexical block scope. Start
13994 a new scope, process the dies, and then close the scope. */
13997 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13999 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14000 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14001 struct context_stack *newobj;
14002 CORE_ADDR lowpc, highpc;
14003 struct die_info *child_die;
14004 CORE_ADDR baseaddr;
14006 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14008 /* Ignore blocks with missing or invalid low and high pc attributes. */
14009 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
14010 as multiple lexical blocks? Handling children in a sane way would
14011 be nasty. Might be easier to properly extend generic blocks to
14012 describe ranges. */
14013 switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
14015 case PC_BOUNDS_NOT_PRESENT:
14016 /* DW_TAG_lexical_block has no attributes, process its children as if
14017 there was no wrapping by that DW_TAG_lexical_block.
14018 GCC does no longer produces such DWARF since GCC r224161. */
14019 for (child_die = die->child;
14020 child_die != NULL && child_die->tag;
14021 child_die = sibling_die (child_die))
14022 process_die (child_die, cu);
14024 case PC_BOUNDS_INVALID:
14027 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14028 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
14030 push_context (0, lowpc);
14031 if (die->child != NULL)
14033 child_die = die->child;
14034 while (child_die && child_die->tag)
14036 process_die (child_die, cu);
14037 child_die = sibling_die (child_die);
14040 inherit_abstract_dies (die, cu);
14041 newobj = pop_context ();
14043 if (local_symbols != NULL || local_using_directives != NULL)
14045 struct block *block
14046 = finish_block (0, &local_symbols, newobj->old_blocks, NULL,
14047 newobj->start_addr, highpc);
14049 /* Note that recording ranges after traversing children, as we
14050 do here, means that recording a parent's ranges entails
14051 walking across all its children's ranges as they appear in
14052 the address map, which is quadratic behavior.
14054 It would be nicer to record the parent's ranges before
14055 traversing its children, simply overriding whatever you find
14056 there. But since we don't even decide whether to create a
14057 block until after we've traversed its children, that's hard
14059 dwarf2_record_block_ranges (die, block, baseaddr, cu);
14061 local_symbols = newobj->locals;
14062 local_using_directives = newobj->local_using_directives;
14065 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
14068 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
14070 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14071 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14072 CORE_ADDR pc, baseaddr;
14073 struct attribute *attr;
14074 struct call_site *call_site, call_site_local;
14077 struct die_info *child_die;
14079 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14081 attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
14084 /* This was a pre-DWARF-5 GNU extension alias
14085 for DW_AT_call_return_pc. */
14086 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14090 complaint (&symfile_complaints,
14091 _("missing DW_AT_call_return_pc for DW_TAG_call_site "
14092 "DIE 0x%x [in module %s]"),
14093 to_underlying (die->sect_off), objfile_name (objfile));
14096 pc = attr_value_as_address (attr) + baseaddr;
14097 pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
14099 if (cu->call_site_htab == NULL)
14100 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
14101 NULL, &objfile->objfile_obstack,
14102 hashtab_obstack_allocate, NULL);
14103 call_site_local.pc = pc;
14104 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
14107 complaint (&symfile_complaints,
14108 _("Duplicate PC %s for DW_TAG_call_site "
14109 "DIE 0x%x [in module %s]"),
14110 paddress (gdbarch, pc), to_underlying (die->sect_off),
14111 objfile_name (objfile));
14115 /* Count parameters at the caller. */
14118 for (child_die = die->child; child_die && child_die->tag;
14119 child_die = sibling_die (child_die))
14121 if (child_die->tag != DW_TAG_call_site_parameter
14122 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14124 complaint (&symfile_complaints,
14125 _("Tag %d is not DW_TAG_call_site_parameter in "
14126 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14127 child_die->tag, to_underlying (child_die->sect_off),
14128 objfile_name (objfile));
14136 = ((struct call_site *)
14137 obstack_alloc (&objfile->objfile_obstack,
14138 sizeof (*call_site)
14139 + (sizeof (*call_site->parameter) * (nparams - 1))));
14141 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
14142 call_site->pc = pc;
14144 if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
14145 || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
14147 struct die_info *func_die;
14149 /* Skip also over DW_TAG_inlined_subroutine. */
14150 for (func_die = die->parent;
14151 func_die && func_die->tag != DW_TAG_subprogram
14152 && func_die->tag != DW_TAG_subroutine_type;
14153 func_die = func_die->parent);
14155 /* DW_AT_call_all_calls is a superset
14156 of DW_AT_call_all_tail_calls. */
14158 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14159 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14160 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14161 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14163 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14164 not complete. But keep CALL_SITE for look ups via call_site_htab,
14165 both the initial caller containing the real return address PC and
14166 the final callee containing the current PC of a chain of tail
14167 calls do not need to have the tail call list complete. But any
14168 function candidate for a virtual tail call frame searched via
14169 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14170 determined unambiguously. */
14174 struct type *func_type = NULL;
14177 func_type = get_die_type (func_die, cu);
14178 if (func_type != NULL)
14180 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14182 /* Enlist this call site to the function. */
14183 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14184 TYPE_TAIL_CALL_LIST (func_type) = call_site;
14187 complaint (&symfile_complaints,
14188 _("Cannot find function owning DW_TAG_call_site "
14189 "DIE 0x%x [in module %s]"),
14190 to_underlying (die->sect_off), objfile_name (objfile));
14194 attr = dwarf2_attr (die, DW_AT_call_target, cu);
14196 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14198 attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14201 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14202 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14204 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14205 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14206 /* Keep NULL DWARF_BLOCK. */;
14207 else if (attr_form_is_block (attr))
14209 struct dwarf2_locexpr_baton *dlbaton;
14211 dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14212 dlbaton->data = DW_BLOCK (attr)->data;
14213 dlbaton->size = DW_BLOCK (attr)->size;
14214 dlbaton->per_cu = cu->per_cu;
14216 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14218 else if (attr_form_is_ref (attr))
14220 struct dwarf2_cu *target_cu = cu;
14221 struct die_info *target_die;
14223 target_die = follow_die_ref (die, attr, &target_cu);
14224 gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14225 if (die_is_declaration (target_die, target_cu))
14227 const char *target_physname;
14229 /* Prefer the mangled name; otherwise compute the demangled one. */
14230 target_physname = dw2_linkage_name (target_die, target_cu);
14231 if (target_physname == NULL)
14232 target_physname = dwarf2_physname (NULL, target_die, target_cu);
14233 if (target_physname == NULL)
14234 complaint (&symfile_complaints,
14235 _("DW_AT_call_target target DIE has invalid "
14236 "physname, for referencing DIE 0x%x [in module %s]"),
14237 to_underlying (die->sect_off), objfile_name (objfile));
14239 SET_FIELD_PHYSNAME (call_site->target, target_physname);
14245 /* DW_AT_entry_pc should be preferred. */
14246 if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14247 <= PC_BOUNDS_INVALID)
14248 complaint (&symfile_complaints,
14249 _("DW_AT_call_target target DIE has invalid "
14250 "low pc, for referencing DIE 0x%x [in module %s]"),
14251 to_underlying (die->sect_off), objfile_name (objfile));
14254 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14255 SET_FIELD_PHYSADDR (call_site->target, lowpc);
14260 complaint (&symfile_complaints,
14261 _("DW_TAG_call_site DW_AT_call_target is neither "
14262 "block nor reference, for DIE 0x%x [in module %s]"),
14263 to_underlying (die->sect_off), objfile_name (objfile));
14265 call_site->per_cu = cu->per_cu;
14267 for (child_die = die->child;
14268 child_die && child_die->tag;
14269 child_die = sibling_die (child_die))
14271 struct call_site_parameter *parameter;
14272 struct attribute *loc, *origin;
14274 if (child_die->tag != DW_TAG_call_site_parameter
14275 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14277 /* Already printed the complaint above. */
14281 gdb_assert (call_site->parameter_count < nparams);
14282 parameter = &call_site->parameter[call_site->parameter_count];
14284 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14285 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14286 register is contained in DW_AT_call_value. */
14288 loc = dwarf2_attr (child_die, DW_AT_location, cu);
14289 origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14290 if (origin == NULL)
14292 /* This was a pre-DWARF-5 GNU extension alias
14293 for DW_AT_call_parameter. */
14294 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14296 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14298 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14300 sect_offset sect_off
14301 = (sect_offset) dwarf2_get_ref_die_offset (origin);
14302 if (!offset_in_cu_p (&cu->header, sect_off))
14304 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14305 binding can be done only inside one CU. Such referenced DIE
14306 therefore cannot be even moved to DW_TAG_partial_unit. */
14307 complaint (&symfile_complaints,
14308 _("DW_AT_call_parameter offset is not in CU for "
14309 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14310 to_underlying (child_die->sect_off),
14311 objfile_name (objfile));
14314 parameter->u.param_cu_off
14315 = (cu_offset) (sect_off - cu->header.sect_off);
14317 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14319 complaint (&symfile_complaints,
14320 _("No DW_FORM_block* DW_AT_location for "
14321 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14322 to_underlying (child_die->sect_off), objfile_name (objfile));
14327 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14328 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14329 if (parameter->u.dwarf_reg != -1)
14330 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14331 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14332 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14333 ¶meter->u.fb_offset))
14334 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14337 complaint (&symfile_complaints,
14338 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
14339 "for DW_FORM_block* DW_AT_location is supported for "
14340 "DW_TAG_call_site child DIE 0x%x "
14342 to_underlying (child_die->sect_off),
14343 objfile_name (objfile));
14348 attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14350 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14351 if (!attr_form_is_block (attr))
14353 complaint (&symfile_complaints,
14354 _("No DW_FORM_block* DW_AT_call_value for "
14355 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14356 to_underlying (child_die->sect_off),
14357 objfile_name (objfile));
14360 parameter->value = DW_BLOCK (attr)->data;
14361 parameter->value_size = DW_BLOCK (attr)->size;
14363 /* Parameters are not pre-cleared by memset above. */
14364 parameter->data_value = NULL;
14365 parameter->data_value_size = 0;
14366 call_site->parameter_count++;
14368 attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14370 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14373 if (!attr_form_is_block (attr))
14374 complaint (&symfile_complaints,
14375 _("No DW_FORM_block* DW_AT_call_data_value for "
14376 "DW_TAG_call_site child DIE 0x%x [in module %s]"),
14377 to_underlying (child_die->sect_off),
14378 objfile_name (objfile));
14381 parameter->data_value = DW_BLOCK (attr)->data;
14382 parameter->data_value_size = DW_BLOCK (attr)->size;
14388 /* Helper function for read_variable. If DIE represents a virtual
14389 table, then return the type of the concrete object that is
14390 associated with the virtual table. Otherwise, return NULL. */
14392 static struct type *
14393 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14395 struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14399 /* Find the type DIE. */
14400 struct die_info *type_die = NULL;
14401 struct dwarf2_cu *type_cu = cu;
14403 if (attr_form_is_ref (attr))
14404 type_die = follow_die_ref (die, attr, &type_cu);
14405 if (type_die == NULL)
14408 if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14410 return die_containing_type (type_die, type_cu);
14413 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14416 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14418 struct rust_vtable_symbol *storage = NULL;
14420 if (cu->language == language_rust)
14422 struct type *containing_type = rust_containing_type (die, cu);
14424 if (containing_type != NULL)
14426 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14428 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14429 struct rust_vtable_symbol);
14430 initialize_objfile_symbol (storage);
14431 storage->concrete_type = containing_type;
14432 storage->subclass = SYMBOL_RUST_VTABLE;
14436 new_symbol (die, NULL, cu, storage);
14439 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14440 reading .debug_rnglists.
14441 Callback's type should be:
14442 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14443 Return true if the attributes are present and valid, otherwise,
14446 template <typename Callback>
14448 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14449 Callback &&callback)
14451 struct dwarf2_per_objfile *dwarf2_per_objfile
14452 = cu->per_cu->dwarf2_per_objfile;
14453 struct objfile *objfile = dwarf2_per_objfile->objfile;
14454 bfd *obfd = objfile->obfd;
14455 /* Base address selection entry. */
14458 const gdb_byte *buffer;
14459 CORE_ADDR baseaddr;
14460 bool overflow = false;
14462 found_base = cu->base_known;
14463 base = cu->base_address;
14465 dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14466 if (offset >= dwarf2_per_objfile->rnglists.size)
14468 complaint (&symfile_complaints,
14469 _("Offset %d out of bounds for DW_AT_ranges attribute"),
14473 buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14475 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14479 /* Initialize it due to a false compiler warning. */
14480 CORE_ADDR range_beginning = 0, range_end = 0;
14481 const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14482 + dwarf2_per_objfile->rnglists.size);
14483 unsigned int bytes_read;
14485 if (buffer == buf_end)
14490 const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14493 case DW_RLE_end_of_list:
14495 case DW_RLE_base_address:
14496 if (buffer + cu->header.addr_size > buf_end)
14501 base = read_address (obfd, buffer, cu, &bytes_read);
14503 buffer += bytes_read;
14505 case DW_RLE_start_length:
14506 if (buffer + cu->header.addr_size > buf_end)
14511 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14512 buffer += bytes_read;
14513 range_end = (range_beginning
14514 + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14515 buffer += bytes_read;
14516 if (buffer > buf_end)
14522 case DW_RLE_offset_pair:
14523 range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14524 buffer += bytes_read;
14525 if (buffer > buf_end)
14530 range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14531 buffer += bytes_read;
14532 if (buffer > buf_end)
14538 case DW_RLE_start_end:
14539 if (buffer + 2 * cu->header.addr_size > buf_end)
14544 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14545 buffer += bytes_read;
14546 range_end = read_address (obfd, buffer, cu, &bytes_read);
14547 buffer += bytes_read;
14550 complaint (&symfile_complaints,
14551 _("Invalid .debug_rnglists data (no base address)"));
14554 if (rlet == DW_RLE_end_of_list || overflow)
14556 if (rlet == DW_RLE_base_address)
14561 /* We have no valid base address for the ranges
14563 complaint (&symfile_complaints,
14564 _("Invalid .debug_rnglists data (no base address)"));
14568 if (range_beginning > range_end)
14570 /* Inverted range entries are invalid. */
14571 complaint (&symfile_complaints,
14572 _("Invalid .debug_rnglists data (inverted range)"));
14576 /* Empty range entries have no effect. */
14577 if (range_beginning == range_end)
14580 range_beginning += base;
14583 /* A not-uncommon case of bad debug info.
14584 Don't pollute the addrmap with bad data. */
14585 if (range_beginning + baseaddr == 0
14586 && !dwarf2_per_objfile->has_section_at_zero)
14588 complaint (&symfile_complaints,
14589 _(".debug_rnglists entry has start address of zero"
14590 " [in module %s]"), objfile_name (objfile));
14594 callback (range_beginning, range_end);
14599 complaint (&symfile_complaints,
14600 _("Offset %d is not terminated "
14601 "for DW_AT_ranges attribute"),
14609 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14610 Callback's type should be:
14611 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14612 Return 1 if the attributes are present and valid, otherwise, return 0. */
14614 template <typename Callback>
14616 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14617 Callback &&callback)
14619 struct dwarf2_per_objfile *dwarf2_per_objfile
14620 = cu->per_cu->dwarf2_per_objfile;
14621 struct objfile *objfile = dwarf2_per_objfile->objfile;
14622 struct comp_unit_head *cu_header = &cu->header;
14623 bfd *obfd = objfile->obfd;
14624 unsigned int addr_size = cu_header->addr_size;
14625 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14626 /* Base address selection entry. */
14629 unsigned int dummy;
14630 const gdb_byte *buffer;
14631 CORE_ADDR baseaddr;
14633 if (cu_header->version >= 5)
14634 return dwarf2_rnglists_process (offset, cu, callback);
14636 found_base = cu->base_known;
14637 base = cu->base_address;
14639 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14640 if (offset >= dwarf2_per_objfile->ranges.size)
14642 complaint (&symfile_complaints,
14643 _("Offset %d out of bounds for DW_AT_ranges attribute"),
14647 buffer = dwarf2_per_objfile->ranges.buffer + offset;
14649 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14653 CORE_ADDR range_beginning, range_end;
14655 range_beginning = read_address (obfd, buffer, cu, &dummy);
14656 buffer += addr_size;
14657 range_end = read_address (obfd, buffer, cu, &dummy);
14658 buffer += addr_size;
14659 offset += 2 * addr_size;
14661 /* An end of list marker is a pair of zero addresses. */
14662 if (range_beginning == 0 && range_end == 0)
14663 /* Found the end of list entry. */
14666 /* Each base address selection entry is a pair of 2 values.
14667 The first is the largest possible address, the second is
14668 the base address. Check for a base address here. */
14669 if ((range_beginning & mask) == mask)
14671 /* If we found the largest possible address, then we already
14672 have the base address in range_end. */
14680 /* We have no valid base address for the ranges
14682 complaint (&symfile_complaints,
14683 _("Invalid .debug_ranges data (no base address)"));
14687 if (range_beginning > range_end)
14689 /* Inverted range entries are invalid. */
14690 complaint (&symfile_complaints,
14691 _("Invalid .debug_ranges data (inverted range)"));
14695 /* Empty range entries have no effect. */
14696 if (range_beginning == range_end)
14699 range_beginning += base;
14702 /* A not-uncommon case of bad debug info.
14703 Don't pollute the addrmap with bad data. */
14704 if (range_beginning + baseaddr == 0
14705 && !dwarf2_per_objfile->has_section_at_zero)
14707 complaint (&symfile_complaints,
14708 _(".debug_ranges entry has start address of zero"
14709 " [in module %s]"), objfile_name (objfile));
14713 callback (range_beginning, range_end);
14719 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14720 Return 1 if the attributes are present and valid, otherwise, return 0.
14721 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14724 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14725 CORE_ADDR *high_return, struct dwarf2_cu *cu,
14726 struct partial_symtab *ranges_pst)
14728 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14729 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14730 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14731 SECT_OFF_TEXT (objfile));
14734 CORE_ADDR high = 0;
14737 retval = dwarf2_ranges_process (offset, cu,
14738 [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14740 if (ranges_pst != NULL)
14745 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch,
14746 range_beginning + baseaddr);
14747 highpc = gdbarch_adjust_dwarf2_addr (gdbarch,
14748 range_end + baseaddr);
14749 addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
14753 /* FIXME: This is recording everything as a low-high
14754 segment of consecutive addresses. We should have a
14755 data structure for discontiguous block ranges
14759 low = range_beginning;
14765 if (range_beginning < low)
14766 low = range_beginning;
14767 if (range_end > high)
14775 /* If the first entry is an end-of-list marker, the range
14776 describes an empty scope, i.e. no instructions. */
14782 *high_return = high;
14786 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14787 definition for the return value. *LOWPC and *HIGHPC are set iff
14788 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14790 static enum pc_bounds_kind
14791 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14792 CORE_ADDR *highpc, struct dwarf2_cu *cu,
14793 struct partial_symtab *pst)
14795 struct dwarf2_per_objfile *dwarf2_per_objfile
14796 = cu->per_cu->dwarf2_per_objfile;
14797 struct attribute *attr;
14798 struct attribute *attr_high;
14800 CORE_ADDR high = 0;
14801 enum pc_bounds_kind ret;
14803 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14806 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14809 low = attr_value_as_address (attr);
14810 high = attr_value_as_address (attr_high);
14811 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14815 /* Found high w/o low attribute. */
14816 return PC_BOUNDS_INVALID;
14818 /* Found consecutive range of addresses. */
14819 ret = PC_BOUNDS_HIGH_LOW;
14823 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14826 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14827 We take advantage of the fact that DW_AT_ranges does not appear
14828 in DW_TAG_compile_unit of DWO files. */
14829 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14830 unsigned int ranges_offset = (DW_UNSND (attr)
14831 + (need_ranges_base
14835 /* Value of the DW_AT_ranges attribute is the offset in the
14836 .debug_ranges section. */
14837 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14838 return PC_BOUNDS_INVALID;
14839 /* Found discontinuous range of addresses. */
14840 ret = PC_BOUNDS_RANGES;
14843 return PC_BOUNDS_NOT_PRESENT;
14846 /* read_partial_die has also the strict LOW < HIGH requirement. */
14848 return PC_BOUNDS_INVALID;
14850 /* When using the GNU linker, .gnu.linkonce. sections are used to
14851 eliminate duplicate copies of functions and vtables and such.
14852 The linker will arbitrarily choose one and discard the others.
14853 The AT_*_pc values for such functions refer to local labels in
14854 these sections. If the section from that file was discarded, the
14855 labels are not in the output, so the relocs get a value of 0.
14856 If this is a discarded function, mark the pc bounds as invalid,
14857 so that GDB will ignore it. */
14858 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14859 return PC_BOUNDS_INVALID;
14867 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14868 its low and high PC addresses. Do nothing if these addresses could not
14869 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14870 and HIGHPC to the high address if greater than HIGHPC. */
14873 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14874 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14875 struct dwarf2_cu *cu)
14877 CORE_ADDR low, high;
14878 struct die_info *child = die->child;
14880 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14882 *lowpc = std::min (*lowpc, low);
14883 *highpc = std::max (*highpc, high);
14886 /* If the language does not allow nested subprograms (either inside
14887 subprograms or lexical blocks), we're done. */
14888 if (cu->language != language_ada)
14891 /* Check all the children of the given DIE. If it contains nested
14892 subprograms, then check their pc bounds. Likewise, we need to
14893 check lexical blocks as well, as they may also contain subprogram
14895 while (child && child->tag)
14897 if (child->tag == DW_TAG_subprogram
14898 || child->tag == DW_TAG_lexical_block)
14899 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14900 child = sibling_die (child);
14904 /* Get the low and high pc's represented by the scope DIE, and store
14905 them in *LOWPC and *HIGHPC. If the correct values can't be
14906 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14909 get_scope_pc_bounds (struct die_info *die,
14910 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14911 struct dwarf2_cu *cu)
14913 CORE_ADDR best_low = (CORE_ADDR) -1;
14914 CORE_ADDR best_high = (CORE_ADDR) 0;
14915 CORE_ADDR current_low, current_high;
14917 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
14918 >= PC_BOUNDS_RANGES)
14920 best_low = current_low;
14921 best_high = current_high;
14925 struct die_info *child = die->child;
14927 while (child && child->tag)
14929 switch (child->tag) {
14930 case DW_TAG_subprogram:
14931 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14933 case DW_TAG_namespace:
14934 case DW_TAG_module:
14935 /* FIXME: carlton/2004-01-16: Should we do this for
14936 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14937 that current GCC's always emit the DIEs corresponding
14938 to definitions of methods of classes as children of a
14939 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14940 the DIEs giving the declarations, which could be
14941 anywhere). But I don't see any reason why the
14942 standards says that they have to be there. */
14943 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
14945 if (current_low != ((CORE_ADDR) -1))
14947 best_low = std::min (best_low, current_low);
14948 best_high = std::max (best_high, current_high);
14956 child = sibling_die (child);
14961 *highpc = best_high;
14964 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14968 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14969 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14971 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14972 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14973 struct attribute *attr;
14974 struct attribute *attr_high;
14976 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14979 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14982 CORE_ADDR low = attr_value_as_address (attr);
14983 CORE_ADDR high = attr_value_as_address (attr_high);
14985 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14988 low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14989 high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14990 record_block_range (block, low, high - 1);
14994 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14997 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14998 We take advantage of the fact that DW_AT_ranges does not appear
14999 in DW_TAG_compile_unit of DWO files. */
15000 int need_ranges_base = die->tag != DW_TAG_compile_unit;
15002 /* The value of the DW_AT_ranges attribute is the offset of the
15003 address range list in the .debug_ranges section. */
15004 unsigned long offset = (DW_UNSND (attr)
15005 + (need_ranges_base ? cu->ranges_base : 0));
15006 const gdb_byte *buffer;
15008 /* For some target architectures, but not others, the
15009 read_address function sign-extends the addresses it returns.
15010 To recognize base address selection entries, we need a
15012 unsigned int addr_size = cu->header.addr_size;
15013 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
15015 /* The base address, to which the next pair is relative. Note
15016 that this 'base' is a DWARF concept: most entries in a range
15017 list are relative, to reduce the number of relocs against the
15018 debugging information. This is separate from this function's
15019 'baseaddr' argument, which GDB uses to relocate debugging
15020 information from a shared library based on the address at
15021 which the library was loaded. */
15022 CORE_ADDR base = cu->base_address;
15023 int base_known = cu->base_known;
15025 dwarf2_ranges_process (offset, cu,
15026 [&] (CORE_ADDR start, CORE_ADDR end)
15030 start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
15031 end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
15032 record_block_range (block, start, end - 1);
15037 /* Check whether the producer field indicates either of GCC < 4.6, or the
15038 Intel C/C++ compiler, and cache the result in CU. */
15041 check_producer (struct dwarf2_cu *cu)
15045 if (cu->producer == NULL)
15047 /* For unknown compilers expect their behavior is DWARF version
15050 GCC started to support .debug_types sections by -gdwarf-4 since
15051 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
15052 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
15053 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
15054 interpreted incorrectly by GDB now - GCC PR debug/48229. */
15056 else if (producer_is_gcc (cu->producer, &major, &minor))
15058 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
15059 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
15061 else if (producer_is_icc (cu->producer, &major, &minor))
15062 cu->producer_is_icc_lt_14 = major < 14;
15065 /* For other non-GCC compilers, expect their behavior is DWARF version
15069 cu->checked_producer = 1;
15072 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
15073 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
15074 during 4.6.0 experimental. */
15077 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
15079 if (!cu->checked_producer)
15080 check_producer (cu);
15082 return cu->producer_is_gxx_lt_4_6;
15085 /* Return the default accessibility type if it is not overriden by
15086 DW_AT_accessibility. */
15088 static enum dwarf_access_attribute
15089 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
15091 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
15093 /* The default DWARF 2 accessibility for members is public, the default
15094 accessibility for inheritance is private. */
15096 if (die->tag != DW_TAG_inheritance)
15097 return DW_ACCESS_public;
15099 return DW_ACCESS_private;
15103 /* DWARF 3+ defines the default accessibility a different way. The same
15104 rules apply now for DW_TAG_inheritance as for the members and it only
15105 depends on the container kind. */
15107 if (die->parent->tag == DW_TAG_class_type)
15108 return DW_ACCESS_private;
15110 return DW_ACCESS_public;
15114 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
15115 offset. If the attribute was not found return 0, otherwise return
15116 1. If it was found but could not properly be handled, set *OFFSET
15120 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
15123 struct attribute *attr;
15125 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
15130 /* Note that we do not check for a section offset first here.
15131 This is because DW_AT_data_member_location is new in DWARF 4,
15132 so if we see it, we can assume that a constant form is really
15133 a constant and not a section offset. */
15134 if (attr_form_is_constant (attr))
15135 *offset = dwarf2_get_attr_constant_value (attr, 0);
15136 else if (attr_form_is_section_offset (attr))
15137 dwarf2_complex_location_expr_complaint ();
15138 else if (attr_form_is_block (attr))
15139 *offset = decode_locdesc (DW_BLOCK (attr), cu);
15141 dwarf2_complex_location_expr_complaint ();
15149 /* Add an aggregate field to the field list. */
15152 dwarf2_add_field (struct field_info *fip, struct die_info *die,
15153 struct dwarf2_cu *cu)
15155 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15156 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15157 struct nextfield *new_field;
15158 struct attribute *attr;
15160 const char *fieldname = "";
15162 /* Allocate a new field list entry and link it in. */
15163 new_field = XNEW (struct nextfield);
15164 make_cleanup (xfree, new_field);
15165 memset (new_field, 0, sizeof (struct nextfield));
15167 if (die->tag == DW_TAG_inheritance)
15169 new_field->next = fip->baseclasses;
15170 fip->baseclasses = new_field;
15174 new_field->next = fip->fields;
15175 fip->fields = new_field;
15179 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15181 new_field->accessibility = DW_UNSND (attr);
15183 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15184 if (new_field->accessibility != DW_ACCESS_public)
15185 fip->non_public_fields = 1;
15187 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15189 new_field->virtuality = DW_UNSND (attr);
15191 new_field->virtuality = DW_VIRTUALITY_none;
15193 fp = &new_field->field;
15195 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15199 /* Data member other than a C++ static data member. */
15201 /* Get type of field. */
15202 fp->type = die_type (die, cu);
15204 SET_FIELD_BITPOS (*fp, 0);
15206 /* Get bit size of field (zero if none). */
15207 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15210 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15214 FIELD_BITSIZE (*fp) = 0;
15217 /* Get bit offset of field. */
15218 if (handle_data_member_location (die, cu, &offset))
15219 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15220 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15223 if (gdbarch_bits_big_endian (gdbarch))
15225 /* For big endian bits, the DW_AT_bit_offset gives the
15226 additional bit offset from the MSB of the containing
15227 anonymous object to the MSB of the field. We don't
15228 have to do anything special since we don't need to
15229 know the size of the anonymous object. */
15230 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15234 /* For little endian bits, compute the bit offset to the
15235 MSB of the anonymous object, subtract off the number of
15236 bits from the MSB of the field to the MSB of the
15237 object, and then subtract off the number of bits of
15238 the field itself. The result is the bit offset of
15239 the LSB of the field. */
15240 int anonymous_size;
15241 int bit_offset = DW_UNSND (attr);
15243 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15246 /* The size of the anonymous object containing
15247 the bit field is explicit, so use the
15248 indicated size (in bytes). */
15249 anonymous_size = DW_UNSND (attr);
15253 /* The size of the anonymous object containing
15254 the bit field must be inferred from the type
15255 attribute of the data member containing the
15257 anonymous_size = TYPE_LENGTH (fp->type);
15259 SET_FIELD_BITPOS (*fp,
15260 (FIELD_BITPOS (*fp)
15261 + anonymous_size * bits_per_byte
15262 - bit_offset - FIELD_BITSIZE (*fp)));
15265 attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15267 SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15268 + dwarf2_get_attr_constant_value (attr, 0)));
15270 /* Get name of field. */
15271 fieldname = dwarf2_name (die, cu);
15272 if (fieldname == NULL)
15275 /* The name is already allocated along with this objfile, so we don't
15276 need to duplicate it for the type. */
15277 fp->name = fieldname;
15279 /* Change accessibility for artificial fields (e.g. virtual table
15280 pointer or virtual base class pointer) to private. */
15281 if (dwarf2_attr (die, DW_AT_artificial, cu))
15283 FIELD_ARTIFICIAL (*fp) = 1;
15284 new_field->accessibility = DW_ACCESS_private;
15285 fip->non_public_fields = 1;
15288 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15290 /* C++ static member. */
15292 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15293 is a declaration, but all versions of G++ as of this writing
15294 (so through at least 3.2.1) incorrectly generate
15295 DW_TAG_variable tags. */
15297 const char *physname;
15299 /* Get name of field. */
15300 fieldname = dwarf2_name (die, cu);
15301 if (fieldname == NULL)
15304 attr = dwarf2_attr (die, DW_AT_const_value, cu);
15306 /* Only create a symbol if this is an external value.
15307 new_symbol checks this and puts the value in the global symbol
15308 table, which we want. If it is not external, new_symbol
15309 will try to put the value in cu->list_in_scope which is wrong. */
15310 && dwarf2_flag_true_p (die, DW_AT_external, cu))
15312 /* A static const member, not much different than an enum as far as
15313 we're concerned, except that we can support more types. */
15314 new_symbol (die, NULL, cu);
15317 /* Get physical name. */
15318 physname = dwarf2_physname (fieldname, die, cu);
15320 /* The name is already allocated along with this objfile, so we don't
15321 need to duplicate it for the type. */
15322 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15323 FIELD_TYPE (*fp) = die_type (die, cu);
15324 FIELD_NAME (*fp) = fieldname;
15326 else if (die->tag == DW_TAG_inheritance)
15330 /* C++ base class field. */
15331 if (handle_data_member_location (die, cu, &offset))
15332 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15333 FIELD_BITSIZE (*fp) = 0;
15334 FIELD_TYPE (*fp) = die_type (die, cu);
15335 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
15336 fip->nbaseclasses++;
15340 /* Can the type given by DIE define another type? */
15343 type_can_define_types (const struct die_info *die)
15347 case DW_TAG_typedef:
15348 case DW_TAG_class_type:
15349 case DW_TAG_structure_type:
15350 case DW_TAG_union_type:
15351 case DW_TAG_enumeration_type:
15359 /* Add a type definition defined in the scope of the FIP's class. */
15362 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15363 struct dwarf2_cu *cu)
15365 struct decl_field_list *new_field;
15366 struct decl_field *fp;
15368 /* Allocate a new field list entry and link it in. */
15369 new_field = XCNEW (struct decl_field_list);
15370 make_cleanup (xfree, new_field);
15372 gdb_assert (type_can_define_types (die));
15374 fp = &new_field->field;
15376 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15377 fp->name = dwarf2_name (die, cu);
15378 fp->type = read_type_die (die, cu);
15380 /* Save accessibility. */
15381 enum dwarf_access_attribute accessibility;
15382 struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15384 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15386 accessibility = dwarf2_default_access_attribute (die, cu);
15387 switch (accessibility)
15389 case DW_ACCESS_public:
15390 /* The assumed value if neither private nor protected. */
15392 case DW_ACCESS_private:
15393 fp->is_private = 1;
15395 case DW_ACCESS_protected:
15396 fp->is_protected = 1;
15399 complaint (&symfile_complaints,
15400 _("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15403 if (die->tag == DW_TAG_typedef)
15405 new_field->next = fip->typedef_field_list;
15406 fip->typedef_field_list = new_field;
15407 fip->typedef_field_list_count++;
15411 new_field->next = fip->nested_types_list;
15412 fip->nested_types_list = new_field;
15413 fip->nested_types_list_count++;
15417 /* Create the vector of fields, and attach it to the type. */
15420 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15421 struct dwarf2_cu *cu)
15423 int nfields = fip->nfields;
15425 /* Record the field count, allocate space for the array of fields,
15426 and create blank accessibility bitfields if necessary. */
15427 TYPE_NFIELDS (type) = nfields;
15428 TYPE_FIELDS (type) = (struct field *)
15429 TYPE_ALLOC (type, sizeof (struct field) * nfields);
15430 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
15432 if (fip->non_public_fields && cu->language != language_ada)
15434 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15436 TYPE_FIELD_PRIVATE_BITS (type) =
15437 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15438 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15440 TYPE_FIELD_PROTECTED_BITS (type) =
15441 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15442 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15444 TYPE_FIELD_IGNORE_BITS (type) =
15445 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15446 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15449 /* If the type has baseclasses, allocate and clear a bit vector for
15450 TYPE_FIELD_VIRTUAL_BITS. */
15451 if (fip->nbaseclasses && cu->language != language_ada)
15453 int num_bytes = B_BYTES (fip->nbaseclasses);
15454 unsigned char *pointer;
15456 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15457 pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15458 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15459 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
15460 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
15463 /* Copy the saved-up fields into the field vector. Start from the head of
15464 the list, adding to the tail of the field array, so that they end up in
15465 the same order in the array in which they were added to the list. */
15466 while (nfields-- > 0)
15468 struct nextfield *fieldp;
15472 fieldp = fip->fields;
15473 fip->fields = fieldp->next;
15477 fieldp = fip->baseclasses;
15478 fip->baseclasses = fieldp->next;
15481 TYPE_FIELD (type, nfields) = fieldp->field;
15482 switch (fieldp->accessibility)
15484 case DW_ACCESS_private:
15485 if (cu->language != language_ada)
15486 SET_TYPE_FIELD_PRIVATE (type, nfields);
15489 case DW_ACCESS_protected:
15490 if (cu->language != language_ada)
15491 SET_TYPE_FIELD_PROTECTED (type, nfields);
15494 case DW_ACCESS_public:
15498 /* Unknown accessibility. Complain and treat it as public. */
15500 complaint (&symfile_complaints, _("unsupported accessibility %d"),
15501 fieldp->accessibility);
15505 if (nfields < fip->nbaseclasses)
15507 switch (fieldp->virtuality)
15509 case DW_VIRTUALITY_virtual:
15510 case DW_VIRTUALITY_pure_virtual:
15511 if (cu->language == language_ada)
15512 error (_("unexpected virtuality in component of Ada type"));
15513 SET_TYPE_FIELD_VIRTUAL (type, nfields);
15520 /* Return true if this member function is a constructor, false
15524 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15526 const char *fieldname;
15527 const char *type_name;
15530 if (die->parent == NULL)
15533 if (die->parent->tag != DW_TAG_structure_type
15534 && die->parent->tag != DW_TAG_union_type
15535 && die->parent->tag != DW_TAG_class_type)
15538 fieldname = dwarf2_name (die, cu);
15539 type_name = dwarf2_name (die->parent, cu);
15540 if (fieldname == NULL || type_name == NULL)
15543 len = strlen (fieldname);
15544 return (strncmp (fieldname, type_name, len) == 0
15545 && (type_name[len] == '\0' || type_name[len] == '<'));
15548 /* Add a member function to the proper fieldlist. */
15551 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15552 struct type *type, struct dwarf2_cu *cu)
15554 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15555 struct attribute *attr;
15556 struct fnfieldlist *flp;
15558 struct fn_field *fnp;
15559 const char *fieldname;
15560 struct nextfnfield *new_fnfield;
15561 struct type *this_type;
15562 enum dwarf_access_attribute accessibility;
15564 if (cu->language == language_ada)
15565 error (_("unexpected member function in Ada type"));
15567 /* Get name of member function. */
15568 fieldname = dwarf2_name (die, cu);
15569 if (fieldname == NULL)
15572 /* Look up member function name in fieldlist. */
15573 for (i = 0; i < fip->nfnfields; i++)
15575 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15579 /* Create new list element if necessary. */
15580 if (i < fip->nfnfields)
15581 flp = &fip->fnfieldlists[i];
15584 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
15586 fip->fnfieldlists = (struct fnfieldlist *)
15587 xrealloc (fip->fnfieldlists,
15588 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
15589 * sizeof (struct fnfieldlist));
15590 if (fip->nfnfields == 0)
15591 make_cleanup (free_current_contents, &fip->fnfieldlists);
15593 flp = &fip->fnfieldlists[fip->nfnfields];
15594 flp->name = fieldname;
15597 i = fip->nfnfields++;
15600 /* Create a new member function field and chain it to the field list
15602 new_fnfield = XNEW (struct nextfnfield);
15603 make_cleanup (xfree, new_fnfield);
15604 memset (new_fnfield, 0, sizeof (struct nextfnfield));
15605 new_fnfield->next = flp->head;
15606 flp->head = new_fnfield;
15609 /* Fill in the member function field info. */
15610 fnp = &new_fnfield->fnfield;
15612 /* Delay processing of the physname until later. */
15613 if (cu->language == language_cplus)
15615 add_to_method_list (type, i, flp->length - 1, fieldname,
15620 const char *physname = dwarf2_physname (fieldname, die, cu);
15621 fnp->physname = physname ? physname : "";
15624 fnp->type = alloc_type (objfile);
15625 this_type = read_type_die (die, cu);
15626 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15628 int nparams = TYPE_NFIELDS (this_type);
15630 /* TYPE is the domain of this method, and THIS_TYPE is the type
15631 of the method itself (TYPE_CODE_METHOD). */
15632 smash_to_method_type (fnp->type, type,
15633 TYPE_TARGET_TYPE (this_type),
15634 TYPE_FIELDS (this_type),
15635 TYPE_NFIELDS (this_type),
15636 TYPE_VARARGS (this_type));
15638 /* Handle static member functions.
15639 Dwarf2 has no clean way to discern C++ static and non-static
15640 member functions. G++ helps GDB by marking the first
15641 parameter for non-static member functions (which is the this
15642 pointer) as artificial. We obtain this information from
15643 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15644 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15645 fnp->voffset = VOFFSET_STATIC;
15648 complaint (&symfile_complaints, _("member function type missing for '%s'"),
15649 dwarf2_full_name (fieldname, die, cu));
15651 /* Get fcontext from DW_AT_containing_type if present. */
15652 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15653 fnp->fcontext = die_containing_type (die, cu);
15655 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15656 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15658 /* Get accessibility. */
15659 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15661 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15663 accessibility = dwarf2_default_access_attribute (die, cu);
15664 switch (accessibility)
15666 case DW_ACCESS_private:
15667 fnp->is_private = 1;
15669 case DW_ACCESS_protected:
15670 fnp->is_protected = 1;
15674 /* Check for artificial methods. */
15675 attr = dwarf2_attr (die, DW_AT_artificial, cu);
15676 if (attr && DW_UNSND (attr) != 0)
15677 fnp->is_artificial = 1;
15679 fnp->is_constructor = dwarf2_is_constructor (die, cu);
15681 /* Get index in virtual function table if it is a virtual member
15682 function. For older versions of GCC, this is an offset in the
15683 appropriate virtual table, as specified by DW_AT_containing_type.
15684 For everyone else, it is an expression to be evaluated relative
15685 to the object address. */
15687 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15690 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15692 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15694 /* Old-style GCC. */
15695 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15697 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15698 || (DW_BLOCK (attr)->size > 1
15699 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15700 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15702 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15703 if ((fnp->voffset % cu->header.addr_size) != 0)
15704 dwarf2_complex_location_expr_complaint ();
15706 fnp->voffset /= cu->header.addr_size;
15710 dwarf2_complex_location_expr_complaint ();
15712 if (!fnp->fcontext)
15714 /* If there is no `this' field and no DW_AT_containing_type,
15715 we cannot actually find a base class context for the
15717 if (TYPE_NFIELDS (this_type) == 0
15718 || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15720 complaint (&symfile_complaints,
15721 _("cannot determine context for virtual member "
15722 "function \"%s\" (offset %d)"),
15723 fieldname, to_underlying (die->sect_off));
15728 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15732 else if (attr_form_is_section_offset (attr))
15734 dwarf2_complex_location_expr_complaint ();
15738 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15744 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15745 if (attr && DW_UNSND (attr))
15747 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15748 complaint (&symfile_complaints,
15749 _("Member function \"%s\" (offset %d) is virtual "
15750 "but the vtable offset is not specified"),
15751 fieldname, to_underlying (die->sect_off));
15752 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15753 TYPE_CPLUS_DYNAMIC (type) = 1;
15758 /* Create the vector of member function fields, and attach it to the type. */
15761 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15762 struct dwarf2_cu *cu)
15764 struct fnfieldlist *flp;
15767 if (cu->language == language_ada)
15768 error (_("unexpected member functions in Ada type"));
15770 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15771 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15772 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
15774 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
15776 struct nextfnfield *nfp = flp->head;
15777 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15780 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
15781 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
15782 fn_flp->fn_fields = (struct fn_field *)
15783 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
15784 for (k = flp->length; (k--, nfp); nfp = nfp->next)
15785 fn_flp->fn_fields[k] = nfp->fnfield;
15788 TYPE_NFN_FIELDS (type) = fip->nfnfields;
15791 /* Returns non-zero if NAME is the name of a vtable member in CU's
15792 language, zero otherwise. */
15794 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15796 static const char vptr[] = "_vptr";
15798 /* Look for the C++ form of the vtable. */
15799 if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15805 /* GCC outputs unnamed structures that are really pointers to member
15806 functions, with the ABI-specified layout. If TYPE describes
15807 such a structure, smash it into a member function type.
15809 GCC shouldn't do this; it should just output pointer to member DIEs.
15810 This is GCC PR debug/28767. */
15813 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15815 struct type *pfn_type, *self_type, *new_type;
15817 /* Check for a structure with no name and two children. */
15818 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15821 /* Check for __pfn and __delta members. */
15822 if (TYPE_FIELD_NAME (type, 0) == NULL
15823 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15824 || TYPE_FIELD_NAME (type, 1) == NULL
15825 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15828 /* Find the type of the method. */
15829 pfn_type = TYPE_FIELD_TYPE (type, 0);
15830 if (pfn_type == NULL
15831 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15832 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15835 /* Look for the "this" argument. */
15836 pfn_type = TYPE_TARGET_TYPE (pfn_type);
15837 if (TYPE_NFIELDS (pfn_type) == 0
15838 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15839 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15842 self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15843 new_type = alloc_type (objfile);
15844 smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15845 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15846 TYPE_VARARGS (pfn_type));
15847 smash_to_methodptr_type (type, new_type);
15851 /* Called when we find the DIE that starts a structure or union scope
15852 (definition) to create a type for the structure or union. Fill in
15853 the type's name and general properties; the members will not be
15854 processed until process_structure_scope. A symbol table entry for
15855 the type will also not be done until process_structure_scope (assuming
15856 the type has a name).
15858 NOTE: we need to call these functions regardless of whether or not the
15859 DIE has a DW_AT_name attribute, since it might be an anonymous
15860 structure or union. This gets the type entered into our set of
15861 user defined types. */
15863 static struct type *
15864 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15866 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15868 struct attribute *attr;
15871 /* If the definition of this type lives in .debug_types, read that type.
15872 Don't follow DW_AT_specification though, that will take us back up
15873 the chain and we want to go down. */
15874 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15877 type = get_DW_AT_signature_type (die, attr, cu);
15879 /* The type's CU may not be the same as CU.
15880 Ensure TYPE is recorded with CU in die_type_hash. */
15881 return set_die_type (die, type, cu);
15884 type = alloc_type (objfile);
15885 INIT_CPLUS_SPECIFIC (type);
15887 name = dwarf2_name (die, cu);
15890 if (cu->language == language_cplus
15891 || cu->language == language_d
15892 || cu->language == language_rust)
15894 const char *full_name = dwarf2_full_name (name, die, cu);
15896 /* dwarf2_full_name might have already finished building the DIE's
15897 type. If so, there is no need to continue. */
15898 if (get_die_type (die, cu) != NULL)
15899 return get_die_type (die, cu);
15901 TYPE_TAG_NAME (type) = full_name;
15902 if (die->tag == DW_TAG_structure_type
15903 || die->tag == DW_TAG_class_type)
15904 TYPE_NAME (type) = TYPE_TAG_NAME (type);
15908 /* The name is already allocated along with this objfile, so
15909 we don't need to duplicate it for the type. */
15910 TYPE_TAG_NAME (type) = name;
15911 if (die->tag == DW_TAG_class_type)
15912 TYPE_NAME (type) = TYPE_TAG_NAME (type);
15916 if (die->tag == DW_TAG_structure_type)
15918 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15920 else if (die->tag == DW_TAG_union_type)
15922 TYPE_CODE (type) = TYPE_CODE_UNION;
15926 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15929 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15930 TYPE_DECLARED_CLASS (type) = 1;
15932 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15935 if (attr_form_is_constant (attr))
15936 TYPE_LENGTH (type) = DW_UNSND (attr);
15939 /* For the moment, dynamic type sizes are not supported
15940 by GDB's struct type. The actual size is determined
15941 on-demand when resolving the type of a given object,
15942 so set the type's length to zero for now. Otherwise,
15943 we record an expression as the length, and that expression
15944 could lead to a very large value, which could eventually
15945 lead to us trying to allocate that much memory when creating
15946 a value of that type. */
15947 TYPE_LENGTH (type) = 0;
15952 TYPE_LENGTH (type) = 0;
15955 if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15957 /* ICC<14 does not output the required DW_AT_declaration on
15958 incomplete types, but gives them a size of zero. */
15959 TYPE_STUB (type) = 1;
15962 TYPE_STUB_SUPPORTED (type) = 1;
15964 if (die_is_declaration (die, cu))
15965 TYPE_STUB (type) = 1;
15966 else if (attr == NULL && die->child == NULL
15967 && producer_is_realview (cu->producer))
15968 /* RealView does not output the required DW_AT_declaration
15969 on incomplete types. */
15970 TYPE_STUB (type) = 1;
15972 /* We need to add the type field to the die immediately so we don't
15973 infinitely recurse when dealing with pointers to the structure
15974 type within the structure itself. */
15975 set_die_type (die, type, cu);
15977 /* set_die_type should be already done. */
15978 set_descriptive_type (type, die, cu);
15983 /* Finish creating a structure or union type, including filling in
15984 its members and creating a symbol for it. */
15987 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
15989 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15990 struct die_info *child_die;
15993 type = get_die_type (die, cu);
15995 type = read_structure_type (die, cu);
15997 if (die->child != NULL && ! die_is_declaration (die, cu))
15999 struct field_info fi;
16000 std::vector<struct symbol *> template_args;
16001 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
16003 memset (&fi, 0, sizeof (struct field_info));
16005 child_die = die->child;
16007 while (child_die && child_die->tag)
16009 if (child_die->tag == DW_TAG_member
16010 || child_die->tag == DW_TAG_variable)
16012 /* NOTE: carlton/2002-11-05: A C++ static data member
16013 should be a DW_TAG_member that is a declaration, but
16014 all versions of G++ as of this writing (so through at
16015 least 3.2.1) incorrectly generate DW_TAG_variable
16016 tags for them instead. */
16017 dwarf2_add_field (&fi, child_die, cu);
16019 else if (child_die->tag == DW_TAG_subprogram)
16021 /* Rust doesn't have member functions in the C++ sense.
16022 However, it does emit ordinary functions as children
16023 of a struct DIE. */
16024 if (cu->language == language_rust)
16025 read_func_scope (child_die, cu);
16028 /* C++ member function. */
16029 dwarf2_add_member_fn (&fi, child_die, type, cu);
16032 else if (child_die->tag == DW_TAG_inheritance)
16034 /* C++ base class field. */
16035 dwarf2_add_field (&fi, child_die, cu);
16037 else if (type_can_define_types (child_die))
16038 dwarf2_add_type_defn (&fi, child_die, cu);
16039 else if (child_die->tag == DW_TAG_template_type_param
16040 || child_die->tag == DW_TAG_template_value_param)
16042 struct symbol *arg = new_symbol (child_die, NULL, cu);
16045 template_args.push_back (arg);
16048 child_die = sibling_die (child_die);
16051 /* Attach template arguments to type. */
16052 if (!template_args.empty ())
16054 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16055 TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16056 TYPE_TEMPLATE_ARGUMENTS (type)
16057 = XOBNEWVEC (&objfile->objfile_obstack,
16059 TYPE_N_TEMPLATE_ARGUMENTS (type));
16060 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16061 template_args.data (),
16062 (TYPE_N_TEMPLATE_ARGUMENTS (type)
16063 * sizeof (struct symbol *)));
16066 /* Attach fields and member functions to the type. */
16068 dwarf2_attach_fields_to_type (&fi, type, cu);
16071 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16073 /* Get the type which refers to the base class (possibly this
16074 class itself) which contains the vtable pointer for the current
16075 class from the DW_AT_containing_type attribute. This use of
16076 DW_AT_containing_type is a GNU extension. */
16078 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16080 struct type *t = die_containing_type (die, cu);
16082 set_type_vptr_basetype (type, t);
16087 /* Our own class provides vtbl ptr. */
16088 for (i = TYPE_NFIELDS (t) - 1;
16089 i >= TYPE_N_BASECLASSES (t);
16092 const char *fieldname = TYPE_FIELD_NAME (t, i);
16094 if (is_vtable_name (fieldname, cu))
16096 set_type_vptr_fieldno (type, i);
16101 /* Complain if virtual function table field not found. */
16102 if (i < TYPE_N_BASECLASSES (t))
16103 complaint (&symfile_complaints,
16104 _("virtual function table pointer "
16105 "not found when defining class '%s'"),
16106 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
16111 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16114 else if (cu->producer
16115 && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16117 /* The IBM XLC compiler does not provide direct indication
16118 of the containing type, but the vtable pointer is
16119 always named __vfp. */
16123 for (i = TYPE_NFIELDS (type) - 1;
16124 i >= TYPE_N_BASECLASSES (type);
16127 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16129 set_type_vptr_fieldno (type, i);
16130 set_type_vptr_basetype (type, type);
16137 /* Copy fi.typedef_field_list linked list elements content into the
16138 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16139 if (fi.typedef_field_list)
16141 int i = fi.typedef_field_list_count;
16143 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16144 TYPE_TYPEDEF_FIELD_ARRAY (type)
16145 = ((struct decl_field *)
16146 TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i));
16147 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
16149 /* Reverse the list order to keep the debug info elements order. */
16152 struct decl_field *dest, *src;
16154 dest = &TYPE_TYPEDEF_FIELD (type, i);
16155 src = &fi.typedef_field_list->field;
16156 fi.typedef_field_list = fi.typedef_field_list->next;
16161 /* Copy fi.nested_types_list linked list elements content into the
16162 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16163 if (fi.nested_types_list != NULL && cu->language != language_ada)
16165 int i = fi.nested_types_list_count;
16167 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16168 TYPE_NESTED_TYPES_ARRAY (type)
16169 = ((struct decl_field *)
16170 TYPE_ALLOC (type, sizeof (struct decl_field) * i));
16171 TYPE_NESTED_TYPES_COUNT (type) = i;
16173 /* Reverse the list order to keep the debug info elements order. */
16176 struct decl_field *dest, *src;
16178 dest = &TYPE_NESTED_TYPES_FIELD (type, i);
16179 src = &fi.nested_types_list->field;
16180 fi.nested_types_list = fi.nested_types_list->next;
16185 do_cleanups (back_to);
16188 quirk_gcc_member_function_pointer (type, objfile);
16190 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16191 snapshots) has been known to create a die giving a declaration
16192 for a class that has, as a child, a die giving a definition for a
16193 nested class. So we have to process our children even if the
16194 current die is a declaration. Normally, of course, a declaration
16195 won't have any children at all. */
16197 child_die = die->child;
16199 while (child_die != NULL && child_die->tag)
16201 if (child_die->tag == DW_TAG_member
16202 || child_die->tag == DW_TAG_variable
16203 || child_die->tag == DW_TAG_inheritance
16204 || child_die->tag == DW_TAG_template_value_param
16205 || child_die->tag == DW_TAG_template_type_param)
16210 process_die (child_die, cu);
16212 child_die = sibling_die (child_die);
16215 /* Do not consider external references. According to the DWARF standard,
16216 these DIEs are identified by the fact that they have no byte_size
16217 attribute, and a declaration attribute. */
16218 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16219 || !die_is_declaration (die, cu))
16220 new_symbol (die, type, cu);
16223 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16224 update TYPE using some information only available in DIE's children. */
16227 update_enumeration_type_from_children (struct die_info *die,
16229 struct dwarf2_cu *cu)
16231 struct die_info *child_die;
16232 int unsigned_enum = 1;
16236 auto_obstack obstack;
16238 for (child_die = die->child;
16239 child_die != NULL && child_die->tag;
16240 child_die = sibling_die (child_die))
16242 struct attribute *attr;
16244 const gdb_byte *bytes;
16245 struct dwarf2_locexpr_baton *baton;
16248 if (child_die->tag != DW_TAG_enumerator)
16251 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16255 name = dwarf2_name (child_die, cu);
16257 name = "<anonymous enumerator>";
16259 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16260 &value, &bytes, &baton);
16266 else if ((mask & value) != 0)
16271 /* If we already know that the enum type is neither unsigned, nor
16272 a flag type, no need to look at the rest of the enumerates. */
16273 if (!unsigned_enum && !flag_enum)
16278 TYPE_UNSIGNED (type) = 1;
16280 TYPE_FLAG_ENUM (type) = 1;
16283 /* Given a DW_AT_enumeration_type die, set its type. We do not
16284 complete the type's fields yet, or create any symbols. */
16286 static struct type *
16287 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16289 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16291 struct attribute *attr;
16294 /* If the definition of this type lives in .debug_types, read that type.
16295 Don't follow DW_AT_specification though, that will take us back up
16296 the chain and we want to go down. */
16297 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16300 type = get_DW_AT_signature_type (die, attr, cu);
16302 /* The type's CU may not be the same as CU.
16303 Ensure TYPE is recorded with CU in die_type_hash. */
16304 return set_die_type (die, type, cu);
16307 type = alloc_type (objfile);
16309 TYPE_CODE (type) = TYPE_CODE_ENUM;
16310 name = dwarf2_full_name (NULL, die, cu);
16312 TYPE_TAG_NAME (type) = name;
16314 attr = dwarf2_attr (die, DW_AT_type, cu);
16317 struct type *underlying_type = die_type (die, cu);
16319 TYPE_TARGET_TYPE (type) = underlying_type;
16322 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16325 TYPE_LENGTH (type) = DW_UNSND (attr);
16329 TYPE_LENGTH (type) = 0;
16332 /* The enumeration DIE can be incomplete. In Ada, any type can be
16333 declared as private in the package spec, and then defined only
16334 inside the package body. Such types are known as Taft Amendment
16335 Types. When another package uses such a type, an incomplete DIE
16336 may be generated by the compiler. */
16337 if (die_is_declaration (die, cu))
16338 TYPE_STUB (type) = 1;
16340 /* Finish the creation of this type by using the enum's children.
16341 We must call this even when the underlying type has been provided
16342 so that we can determine if we're looking at a "flag" enum. */
16343 update_enumeration_type_from_children (die, type, cu);
16345 /* If this type has an underlying type that is not a stub, then we
16346 may use its attributes. We always use the "unsigned" attribute
16347 in this situation, because ordinarily we guess whether the type
16348 is unsigned -- but the guess can be wrong and the underlying type
16349 can tell us the reality. However, we defer to a local size
16350 attribute if one exists, because this lets the compiler override
16351 the underlying type if needed. */
16352 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16354 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16355 if (TYPE_LENGTH (type) == 0)
16356 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16359 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16361 return set_die_type (die, type, cu);
16364 /* Given a pointer to a die which begins an enumeration, process all
16365 the dies that define the members of the enumeration, and create the
16366 symbol for the enumeration type.
16368 NOTE: We reverse the order of the element list. */
16371 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16373 struct type *this_type;
16375 this_type = get_die_type (die, cu);
16376 if (this_type == NULL)
16377 this_type = read_enumeration_type (die, cu);
16379 if (die->child != NULL)
16381 struct die_info *child_die;
16382 struct symbol *sym;
16383 struct field *fields = NULL;
16384 int num_fields = 0;
16387 child_die = die->child;
16388 while (child_die && child_die->tag)
16390 if (child_die->tag != DW_TAG_enumerator)
16392 process_die (child_die, cu);
16396 name = dwarf2_name (child_die, cu);
16399 sym = new_symbol (child_die, this_type, cu);
16401 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16403 fields = (struct field *)
16405 (num_fields + DW_FIELD_ALLOC_CHUNK)
16406 * sizeof (struct field));
16409 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16410 FIELD_TYPE (fields[num_fields]) = NULL;
16411 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16412 FIELD_BITSIZE (fields[num_fields]) = 0;
16418 child_die = sibling_die (child_die);
16423 TYPE_NFIELDS (this_type) = num_fields;
16424 TYPE_FIELDS (this_type) = (struct field *)
16425 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16426 memcpy (TYPE_FIELDS (this_type), fields,
16427 sizeof (struct field) * num_fields);
16432 /* If we are reading an enum from a .debug_types unit, and the enum
16433 is a declaration, and the enum is not the signatured type in the
16434 unit, then we do not want to add a symbol for it. Adding a
16435 symbol would in some cases obscure the true definition of the
16436 enum, giving users an incomplete type when the definition is
16437 actually available. Note that we do not want to do this for all
16438 enums which are just declarations, because C++0x allows forward
16439 enum declarations. */
16440 if (cu->per_cu->is_debug_types
16441 && die_is_declaration (die, cu))
16443 struct signatured_type *sig_type;
16445 sig_type = (struct signatured_type *) cu->per_cu;
16446 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16447 if (sig_type->type_offset_in_section != die->sect_off)
16451 new_symbol (die, this_type, cu);
16454 /* Extract all information from a DW_TAG_array_type DIE and put it in
16455 the DIE's type field. For now, this only handles one dimensional
16458 static struct type *
16459 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16461 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16462 struct die_info *child_die;
16464 struct type *element_type, *range_type, *index_type;
16465 struct attribute *attr;
16467 struct dynamic_prop *byte_stride_prop = NULL;
16468 unsigned int bit_stride = 0;
16470 element_type = die_type (die, cu);
16472 /* The die_type call above may have already set the type for this DIE. */
16473 type = get_die_type (die, cu);
16477 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16483 = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16484 stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16487 complaint (&symfile_complaints,
16488 _("unable to read array DW_AT_byte_stride "
16489 " - DIE at 0x%x [in module %s]"),
16490 to_underlying (die->sect_off),
16491 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16492 /* Ignore this attribute. We will likely not be able to print
16493 arrays of this type correctly, but there is little we can do
16494 to help if we cannot read the attribute's value. */
16495 byte_stride_prop = NULL;
16499 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16501 bit_stride = DW_UNSND (attr);
16503 /* Irix 6.2 native cc creates array types without children for
16504 arrays with unspecified length. */
16505 if (die->child == NULL)
16507 index_type = objfile_type (objfile)->builtin_int;
16508 range_type = create_static_range_type (NULL, index_type, 0, -1);
16509 type = create_array_type_with_stride (NULL, element_type, range_type,
16510 byte_stride_prop, bit_stride);
16511 return set_die_type (die, type, cu);
16514 std::vector<struct type *> range_types;
16515 child_die = die->child;
16516 while (child_die && child_die->tag)
16518 if (child_die->tag == DW_TAG_subrange_type)
16520 struct type *child_type = read_type_die (child_die, cu);
16522 if (child_type != NULL)
16524 /* The range type was succesfully read. Save it for the
16525 array type creation. */
16526 range_types.push_back (child_type);
16529 child_die = sibling_die (child_die);
16532 /* Dwarf2 dimensions are output from left to right, create the
16533 necessary array types in backwards order. */
16535 type = element_type;
16537 if (read_array_order (die, cu) == DW_ORD_col_major)
16541 while (i < range_types.size ())
16542 type = create_array_type_with_stride (NULL, type, range_types[i++],
16543 byte_stride_prop, bit_stride);
16547 size_t ndim = range_types.size ();
16549 type = create_array_type_with_stride (NULL, type, range_types[ndim],
16550 byte_stride_prop, bit_stride);
16553 /* Understand Dwarf2 support for vector types (like they occur on
16554 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16555 array type. This is not part of the Dwarf2/3 standard yet, but a
16556 custom vendor extension. The main difference between a regular
16557 array and the vector variant is that vectors are passed by value
16559 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16561 make_vector_type (type);
16563 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16564 implementation may choose to implement triple vectors using this
16566 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16569 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16570 TYPE_LENGTH (type) = DW_UNSND (attr);
16572 complaint (&symfile_complaints,
16573 _("DW_AT_byte_size for array type smaller "
16574 "than the total size of elements"));
16577 name = dwarf2_name (die, cu);
16579 TYPE_NAME (type) = name;
16581 /* Install the type in the die. */
16582 set_die_type (die, type, cu);
16584 /* set_die_type should be already done. */
16585 set_descriptive_type (type, die, cu);
16590 static enum dwarf_array_dim_ordering
16591 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16593 struct attribute *attr;
16595 attr = dwarf2_attr (die, DW_AT_ordering, cu);
16598 return (enum dwarf_array_dim_ordering) DW_SND (attr);
16600 /* GNU F77 is a special case, as at 08/2004 array type info is the
16601 opposite order to the dwarf2 specification, but data is still
16602 laid out as per normal fortran.
16604 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16605 version checking. */
16607 if (cu->language == language_fortran
16608 && cu->producer && strstr (cu->producer, "GNU F77"))
16610 return DW_ORD_row_major;
16613 switch (cu->language_defn->la_array_ordering)
16615 case array_column_major:
16616 return DW_ORD_col_major;
16617 case array_row_major:
16619 return DW_ORD_row_major;
16623 /* Extract all information from a DW_TAG_set_type DIE and put it in
16624 the DIE's type field. */
16626 static struct type *
16627 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16629 struct type *domain_type, *set_type;
16630 struct attribute *attr;
16632 domain_type = die_type (die, cu);
16634 /* The die_type call above may have already set the type for this DIE. */
16635 set_type = get_die_type (die, cu);
16639 set_type = create_set_type (NULL, domain_type);
16641 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16643 TYPE_LENGTH (set_type) = DW_UNSND (attr);
16645 return set_die_type (die, set_type, cu);
16648 /* A helper for read_common_block that creates a locexpr baton.
16649 SYM is the symbol which we are marking as computed.
16650 COMMON_DIE is the DIE for the common block.
16651 COMMON_LOC is the location expression attribute for the common
16653 MEMBER_LOC is the location expression attribute for the particular
16654 member of the common block that we are processing.
16655 CU is the CU from which the above come. */
16658 mark_common_block_symbol_computed (struct symbol *sym,
16659 struct die_info *common_die,
16660 struct attribute *common_loc,
16661 struct attribute *member_loc,
16662 struct dwarf2_cu *cu)
16664 struct dwarf2_per_objfile *dwarf2_per_objfile
16665 = cu->per_cu->dwarf2_per_objfile;
16666 struct objfile *objfile = dwarf2_per_objfile->objfile;
16667 struct dwarf2_locexpr_baton *baton;
16669 unsigned int cu_off;
16670 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16671 LONGEST offset = 0;
16673 gdb_assert (common_loc && member_loc);
16674 gdb_assert (attr_form_is_block (common_loc));
16675 gdb_assert (attr_form_is_block (member_loc)
16676 || attr_form_is_constant (member_loc));
16678 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16679 baton->per_cu = cu->per_cu;
16680 gdb_assert (baton->per_cu);
16682 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16684 if (attr_form_is_constant (member_loc))
16686 offset = dwarf2_get_attr_constant_value (member_loc, 0);
16687 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16690 baton->size += DW_BLOCK (member_loc)->size;
16692 ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16695 *ptr++ = DW_OP_call4;
16696 cu_off = common_die->sect_off - cu->per_cu->sect_off;
16697 store_unsigned_integer (ptr, 4, byte_order, cu_off);
16700 if (attr_form_is_constant (member_loc))
16702 *ptr++ = DW_OP_addr;
16703 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16704 ptr += cu->header.addr_size;
16708 /* We have to copy the data here, because DW_OP_call4 will only
16709 use a DW_AT_location attribute. */
16710 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16711 ptr += DW_BLOCK (member_loc)->size;
16714 *ptr++ = DW_OP_plus;
16715 gdb_assert (ptr - baton->data == baton->size);
16717 SYMBOL_LOCATION_BATON (sym) = baton;
16718 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16721 /* Create appropriate locally-scoped variables for all the
16722 DW_TAG_common_block entries. Also create a struct common_block
16723 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16724 is used to sepate the common blocks name namespace from regular
16728 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16730 struct attribute *attr;
16732 attr = dwarf2_attr (die, DW_AT_location, cu);
16735 /* Support the .debug_loc offsets. */
16736 if (attr_form_is_block (attr))
16740 else if (attr_form_is_section_offset (attr))
16742 dwarf2_complex_location_expr_complaint ();
16747 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16748 "common block member");
16753 if (die->child != NULL)
16755 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16756 struct die_info *child_die;
16757 size_t n_entries = 0, size;
16758 struct common_block *common_block;
16759 struct symbol *sym;
16761 for (child_die = die->child;
16762 child_die && child_die->tag;
16763 child_die = sibling_die (child_die))
16766 size = (sizeof (struct common_block)
16767 + (n_entries - 1) * sizeof (struct symbol *));
16769 = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16771 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16772 common_block->n_entries = 0;
16774 for (child_die = die->child;
16775 child_die && child_die->tag;
16776 child_die = sibling_die (child_die))
16778 /* Create the symbol in the DW_TAG_common_block block in the current
16780 sym = new_symbol (child_die, NULL, cu);
16783 struct attribute *member_loc;
16785 common_block->contents[common_block->n_entries++] = sym;
16787 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16791 /* GDB has handled this for a long time, but it is
16792 not specified by DWARF. It seems to have been
16793 emitted by gfortran at least as recently as:
16794 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16795 complaint (&symfile_complaints,
16796 _("Variable in common block has "
16797 "DW_AT_data_member_location "
16798 "- DIE at 0x%x [in module %s]"),
16799 to_underlying (child_die->sect_off),
16800 objfile_name (objfile));
16802 if (attr_form_is_section_offset (member_loc))
16803 dwarf2_complex_location_expr_complaint ();
16804 else if (attr_form_is_constant (member_loc)
16805 || attr_form_is_block (member_loc))
16808 mark_common_block_symbol_computed (sym, die, attr,
16812 dwarf2_complex_location_expr_complaint ();
16817 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16818 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16822 /* Create a type for a C++ namespace. */
16824 static struct type *
16825 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16827 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16828 const char *previous_prefix, *name;
16832 /* For extensions, reuse the type of the original namespace. */
16833 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16835 struct die_info *ext_die;
16836 struct dwarf2_cu *ext_cu = cu;
16838 ext_die = dwarf2_extension (die, &ext_cu);
16839 type = read_type_die (ext_die, ext_cu);
16841 /* EXT_CU may not be the same as CU.
16842 Ensure TYPE is recorded with CU in die_type_hash. */
16843 return set_die_type (die, type, cu);
16846 name = namespace_name (die, &is_anonymous, cu);
16848 /* Now build the name of the current namespace. */
16850 previous_prefix = determine_prefix (die, cu);
16851 if (previous_prefix[0] != '\0')
16852 name = typename_concat (&objfile->objfile_obstack,
16853 previous_prefix, name, 0, cu);
16855 /* Create the type. */
16856 type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16857 TYPE_TAG_NAME (type) = TYPE_NAME (type);
16859 return set_die_type (die, type, cu);
16862 /* Read a namespace scope. */
16865 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16867 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16870 /* Add a symbol associated to this if we haven't seen the namespace
16871 before. Also, add a using directive if it's an anonymous
16874 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16878 type = read_type_die (die, cu);
16879 new_symbol (die, type, cu);
16881 namespace_name (die, &is_anonymous, cu);
16884 const char *previous_prefix = determine_prefix (die, cu);
16886 std::vector<const char *> excludes;
16887 add_using_directive (using_directives (cu->language),
16888 previous_prefix, TYPE_NAME (type), NULL,
16889 NULL, excludes, 0, &objfile->objfile_obstack);
16893 if (die->child != NULL)
16895 struct die_info *child_die = die->child;
16897 while (child_die && child_die->tag)
16899 process_die (child_die, cu);
16900 child_die = sibling_die (child_die);
16905 /* Read a Fortran module as type. This DIE can be only a declaration used for
16906 imported module. Still we need that type as local Fortran "use ... only"
16907 declaration imports depend on the created type in determine_prefix. */
16909 static struct type *
16910 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16912 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16913 const char *module_name;
16916 module_name = dwarf2_name (die, cu);
16918 complaint (&symfile_complaints,
16919 _("DW_TAG_module has no name, offset 0x%x"),
16920 to_underlying (die->sect_off));
16921 type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16923 /* determine_prefix uses TYPE_TAG_NAME. */
16924 TYPE_TAG_NAME (type) = TYPE_NAME (type);
16926 return set_die_type (die, type, cu);
16929 /* Read a Fortran module. */
16932 read_module (struct die_info *die, struct dwarf2_cu *cu)
16934 struct die_info *child_die = die->child;
16937 type = read_type_die (die, cu);
16938 new_symbol (die, type, cu);
16940 while (child_die && child_die->tag)
16942 process_die (child_die, cu);
16943 child_die = sibling_die (child_die);
16947 /* Return the name of the namespace represented by DIE. Set
16948 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16951 static const char *
16952 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16954 struct die_info *current_die;
16955 const char *name = NULL;
16957 /* Loop through the extensions until we find a name. */
16959 for (current_die = die;
16960 current_die != NULL;
16961 current_die = dwarf2_extension (die, &cu))
16963 /* We don't use dwarf2_name here so that we can detect the absence
16964 of a name -> anonymous namespace. */
16965 name = dwarf2_string_attr (die, DW_AT_name, cu);
16971 /* Is it an anonymous namespace? */
16973 *is_anonymous = (name == NULL);
16975 name = CP_ANONYMOUS_NAMESPACE_STR;
16980 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16981 the user defined type vector. */
16983 static struct type *
16984 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16986 struct gdbarch *gdbarch
16987 = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16988 struct comp_unit_head *cu_header = &cu->header;
16990 struct attribute *attr_byte_size;
16991 struct attribute *attr_address_class;
16992 int byte_size, addr_class;
16993 struct type *target_type;
16995 target_type = die_type (die, cu);
16997 /* The die_type call above may have already set the type for this DIE. */
16998 type = get_die_type (die, cu);
17002 type = lookup_pointer_type (target_type);
17004 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17005 if (attr_byte_size)
17006 byte_size = DW_UNSND (attr_byte_size);
17008 byte_size = cu_header->addr_size;
17010 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17011 if (attr_address_class)
17012 addr_class = DW_UNSND (attr_address_class);
17014 addr_class = DW_ADDR_none;
17016 /* If the pointer size or address class is different than the
17017 default, create a type variant marked as such and set the
17018 length accordingly. */
17019 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
17021 if (gdbarch_address_class_type_flags_p (gdbarch))
17025 type_flags = gdbarch_address_class_type_flags
17026 (gdbarch, byte_size, addr_class);
17027 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17029 type = make_type_with_address_space (type, type_flags);
17031 else if (TYPE_LENGTH (type) != byte_size)
17033 complaint (&symfile_complaints,
17034 _("invalid pointer size %d"), byte_size);
17038 /* Should we also complain about unhandled address classes? */
17042 TYPE_LENGTH (type) = byte_size;
17043 return set_die_type (die, type, cu);
17046 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17047 the user defined type vector. */
17049 static struct type *
17050 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17053 struct type *to_type;
17054 struct type *domain;
17056 to_type = die_type (die, cu);
17057 domain = die_containing_type (die, cu);
17059 /* The calls above may have already set the type for this DIE. */
17060 type = get_die_type (die, cu);
17064 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17065 type = lookup_methodptr_type (to_type);
17066 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17068 struct type *new_type
17069 = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17071 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17072 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17073 TYPE_VARARGS (to_type));
17074 type = lookup_methodptr_type (new_type);
17077 type = lookup_memberptr_type (to_type, domain);
17079 return set_die_type (die, type, cu);
17082 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17083 the user defined type vector. */
17085 static struct type *
17086 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17087 enum type_code refcode)
17089 struct comp_unit_head *cu_header = &cu->header;
17090 struct type *type, *target_type;
17091 struct attribute *attr;
17093 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17095 target_type = die_type (die, cu);
17097 /* The die_type call above may have already set the type for this DIE. */
17098 type = get_die_type (die, cu);
17102 type = lookup_reference_type (target_type, refcode);
17103 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17106 TYPE_LENGTH (type) = DW_UNSND (attr);
17110 TYPE_LENGTH (type) = cu_header->addr_size;
17112 return set_die_type (die, type, cu);
17115 /* Add the given cv-qualifiers to the element type of the array. GCC
17116 outputs DWARF type qualifiers that apply to an array, not the
17117 element type. But GDB relies on the array element type to carry
17118 the cv-qualifiers. This mimics section 6.7.3 of the C99
17121 static struct type *
17122 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17123 struct type *base_type, int cnst, int voltl)
17125 struct type *el_type, *inner_array;
17127 base_type = copy_type (base_type);
17128 inner_array = base_type;
17130 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17132 TYPE_TARGET_TYPE (inner_array) =
17133 copy_type (TYPE_TARGET_TYPE (inner_array));
17134 inner_array = TYPE_TARGET_TYPE (inner_array);
17137 el_type = TYPE_TARGET_TYPE (inner_array);
17138 cnst |= TYPE_CONST (el_type);
17139 voltl |= TYPE_VOLATILE (el_type);
17140 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17142 return set_die_type (die, base_type, cu);
17145 static struct type *
17146 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17148 struct type *base_type, *cv_type;
17150 base_type = die_type (die, cu);
17152 /* The die_type call above may have already set the type for this DIE. */
17153 cv_type = get_die_type (die, cu);
17157 /* In case the const qualifier is applied to an array type, the element type
17158 is so qualified, not the array type (section 6.7.3 of C99). */
17159 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17160 return add_array_cv_type (die, cu, base_type, 1, 0);
17162 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17163 return set_die_type (die, cv_type, cu);
17166 static struct type *
17167 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17169 struct type *base_type, *cv_type;
17171 base_type = die_type (die, cu);
17173 /* The die_type call above may have already set the type for this DIE. */
17174 cv_type = get_die_type (die, cu);
17178 /* In case the volatile qualifier is applied to an array type, the
17179 element type is so qualified, not the array type (section 6.7.3
17181 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17182 return add_array_cv_type (die, cu, base_type, 0, 1);
17184 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17185 return set_die_type (die, cv_type, cu);
17188 /* Handle DW_TAG_restrict_type. */
17190 static struct type *
17191 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17193 struct type *base_type, *cv_type;
17195 base_type = die_type (die, cu);
17197 /* The die_type call above may have already set the type for this DIE. */
17198 cv_type = get_die_type (die, cu);
17202 cv_type = make_restrict_type (base_type);
17203 return set_die_type (die, cv_type, cu);
17206 /* Handle DW_TAG_atomic_type. */
17208 static struct type *
17209 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17211 struct type *base_type, *cv_type;
17213 base_type = die_type (die, cu);
17215 /* The die_type call above may have already set the type for this DIE. */
17216 cv_type = get_die_type (die, cu);
17220 cv_type = make_atomic_type (base_type);
17221 return set_die_type (die, cv_type, cu);
17224 /* Extract all information from a DW_TAG_string_type DIE and add to
17225 the user defined type vector. It isn't really a user defined type,
17226 but it behaves like one, with other DIE's using an AT_user_def_type
17227 attribute to reference it. */
17229 static struct type *
17230 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17232 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17233 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17234 struct type *type, *range_type, *index_type, *char_type;
17235 struct attribute *attr;
17236 unsigned int length;
17238 attr = dwarf2_attr (die, DW_AT_string_length, cu);
17241 length = DW_UNSND (attr);
17245 /* Check for the DW_AT_byte_size attribute. */
17246 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17249 length = DW_UNSND (attr);
17257 index_type = objfile_type (objfile)->builtin_int;
17258 range_type = create_static_range_type (NULL, index_type, 1, length);
17259 char_type = language_string_char_type (cu->language_defn, gdbarch);
17260 type = create_string_type (NULL, char_type, range_type);
17262 return set_die_type (die, type, cu);
17265 /* Assuming that DIE corresponds to a function, returns nonzero
17266 if the function is prototyped. */
17269 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17271 struct attribute *attr;
17273 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17274 if (attr && (DW_UNSND (attr) != 0))
17277 /* The DWARF standard implies that the DW_AT_prototyped attribute
17278 is only meaninful for C, but the concept also extends to other
17279 languages that allow unprototyped functions (Eg: Objective C).
17280 For all other languages, assume that functions are always
17282 if (cu->language != language_c
17283 && cu->language != language_objc
17284 && cu->language != language_opencl)
17287 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17288 prototyped and unprototyped functions; default to prototyped,
17289 since that is more common in modern code (and RealView warns
17290 about unprototyped functions). */
17291 if (producer_is_realview (cu->producer))
17297 /* Handle DIES due to C code like:
17301 int (*funcp)(int a, long l);
17305 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17307 static struct type *
17308 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17310 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17311 struct type *type; /* Type that this function returns. */
17312 struct type *ftype; /* Function that returns above type. */
17313 struct attribute *attr;
17315 type = die_type (die, cu);
17317 /* The die_type call above may have already set the type for this DIE. */
17318 ftype = get_die_type (die, cu);
17322 ftype = lookup_function_type (type);
17324 if (prototyped_function_p (die, cu))
17325 TYPE_PROTOTYPED (ftype) = 1;
17327 /* Store the calling convention in the type if it's available in
17328 the subroutine die. Otherwise set the calling convention to
17329 the default value DW_CC_normal. */
17330 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17332 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17333 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17334 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17336 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17338 /* Record whether the function returns normally to its caller or not
17339 if the DWARF producer set that information. */
17340 attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17341 if (attr && (DW_UNSND (attr) != 0))
17342 TYPE_NO_RETURN (ftype) = 1;
17344 /* We need to add the subroutine type to the die immediately so
17345 we don't infinitely recurse when dealing with parameters
17346 declared as the same subroutine type. */
17347 set_die_type (die, ftype, cu);
17349 if (die->child != NULL)
17351 struct type *void_type = objfile_type (objfile)->builtin_void;
17352 struct die_info *child_die;
17353 int nparams, iparams;
17355 /* Count the number of parameters.
17356 FIXME: GDB currently ignores vararg functions, but knows about
17357 vararg member functions. */
17359 child_die = die->child;
17360 while (child_die && child_die->tag)
17362 if (child_die->tag == DW_TAG_formal_parameter)
17364 else if (child_die->tag == DW_TAG_unspecified_parameters)
17365 TYPE_VARARGS (ftype) = 1;
17366 child_die = sibling_die (child_die);
17369 /* Allocate storage for parameters and fill them in. */
17370 TYPE_NFIELDS (ftype) = nparams;
17371 TYPE_FIELDS (ftype) = (struct field *)
17372 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17374 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17375 even if we error out during the parameters reading below. */
17376 for (iparams = 0; iparams < nparams; iparams++)
17377 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17380 child_die = die->child;
17381 while (child_die && child_die->tag)
17383 if (child_die->tag == DW_TAG_formal_parameter)
17385 struct type *arg_type;
17387 /* DWARF version 2 has no clean way to discern C++
17388 static and non-static member functions. G++ helps
17389 GDB by marking the first parameter for non-static
17390 member functions (which is the this pointer) as
17391 artificial. We pass this information to
17392 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17394 DWARF version 3 added DW_AT_object_pointer, which GCC
17395 4.5 does not yet generate. */
17396 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17398 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17400 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17401 arg_type = die_type (child_die, cu);
17403 /* RealView does not mark THIS as const, which the testsuite
17404 expects. GCC marks THIS as const in method definitions,
17405 but not in the class specifications (GCC PR 43053). */
17406 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17407 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17410 struct dwarf2_cu *arg_cu = cu;
17411 const char *name = dwarf2_name (child_die, cu);
17413 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17416 /* If the compiler emits this, use it. */
17417 if (follow_die_ref (die, attr, &arg_cu) == child_die)
17420 else if (name && strcmp (name, "this") == 0)
17421 /* Function definitions will have the argument names. */
17423 else if (name == NULL && iparams == 0)
17424 /* Declarations may not have the names, so like
17425 elsewhere in GDB, assume an artificial first
17426 argument is "this". */
17430 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17434 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17437 child_die = sibling_die (child_die);
17444 static struct type *
17445 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17447 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17448 const char *name = NULL;
17449 struct type *this_type, *target_type;
17451 name = dwarf2_full_name (NULL, die, cu);
17452 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17453 TYPE_TARGET_STUB (this_type) = 1;
17454 set_die_type (die, this_type, cu);
17455 target_type = die_type (die, cu);
17456 if (target_type != this_type)
17457 TYPE_TARGET_TYPE (this_type) = target_type;
17460 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17461 spec and cause infinite loops in GDB. */
17462 complaint (&symfile_complaints,
17463 _("Self-referential DW_TAG_typedef "
17464 "- DIE at 0x%x [in module %s]"),
17465 to_underlying (die->sect_off), objfile_name (objfile));
17466 TYPE_TARGET_TYPE (this_type) = NULL;
17471 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17472 (which may be different from NAME) to the architecture back-end to allow
17473 it to guess the correct format if necessary. */
17475 static struct type *
17476 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17477 const char *name_hint)
17479 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17480 const struct floatformat **format;
17483 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17485 type = init_float_type (objfile, bits, name, format);
17487 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17492 /* Find a representation of a given base type and install
17493 it in the TYPE field of the die. */
17495 static struct type *
17496 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17498 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17500 struct attribute *attr;
17501 int encoding = 0, bits = 0;
17504 attr = dwarf2_attr (die, DW_AT_encoding, cu);
17507 encoding = DW_UNSND (attr);
17509 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17512 bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17514 name = dwarf2_name (die, cu);
17517 complaint (&symfile_complaints,
17518 _("DW_AT_name missing from DW_TAG_base_type"));
17523 case DW_ATE_address:
17524 /* Turn DW_ATE_address into a void * pointer. */
17525 type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17526 type = init_pointer_type (objfile, bits, name, type);
17528 case DW_ATE_boolean:
17529 type = init_boolean_type (objfile, bits, 1, name);
17531 case DW_ATE_complex_float:
17532 type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17533 type = init_complex_type (objfile, name, type);
17535 case DW_ATE_decimal_float:
17536 type = init_decfloat_type (objfile, bits, name);
17539 type = dwarf2_init_float_type (objfile, bits, name, name);
17541 case DW_ATE_signed:
17542 type = init_integer_type (objfile, bits, 0, name);
17544 case DW_ATE_unsigned:
17545 if (cu->language == language_fortran
17547 && startswith (name, "character("))
17548 type = init_character_type (objfile, bits, 1, name);
17550 type = init_integer_type (objfile, bits, 1, name);
17552 case DW_ATE_signed_char:
17553 if (cu->language == language_ada || cu->language == language_m2
17554 || cu->language == language_pascal
17555 || cu->language == language_fortran)
17556 type = init_character_type (objfile, bits, 0, name);
17558 type = init_integer_type (objfile, bits, 0, name);
17560 case DW_ATE_unsigned_char:
17561 if (cu->language == language_ada || cu->language == language_m2
17562 || cu->language == language_pascal
17563 || cu->language == language_fortran
17564 || cu->language == language_rust)
17565 type = init_character_type (objfile, bits, 1, name);
17567 type = init_integer_type (objfile, bits, 1, name);
17571 gdbarch *arch = get_objfile_arch (objfile);
17574 type = builtin_type (arch)->builtin_char16;
17575 else if (bits == 32)
17576 type = builtin_type (arch)->builtin_char32;
17579 complaint (&symfile_complaints,
17580 _("unsupported DW_ATE_UTF bit size: '%d'"),
17582 type = init_integer_type (objfile, bits, 1, name);
17584 return set_die_type (die, type, cu);
17589 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
17590 dwarf_type_encoding_name (encoding));
17591 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17595 if (name && strcmp (name, "char") == 0)
17596 TYPE_NOSIGN (type) = 1;
17598 return set_die_type (die, type, cu);
17601 /* Parse dwarf attribute if it's a block, reference or constant and put the
17602 resulting value of the attribute into struct bound_prop.
17603 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17606 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17607 struct dwarf2_cu *cu, struct dynamic_prop *prop)
17609 struct dwarf2_property_baton *baton;
17610 struct obstack *obstack
17611 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17613 if (attr == NULL || prop == NULL)
17616 if (attr_form_is_block (attr))
17618 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17619 baton->referenced_type = NULL;
17620 baton->locexpr.per_cu = cu->per_cu;
17621 baton->locexpr.size = DW_BLOCK (attr)->size;
17622 baton->locexpr.data = DW_BLOCK (attr)->data;
17623 prop->data.baton = baton;
17624 prop->kind = PROP_LOCEXPR;
17625 gdb_assert (prop->data.baton != NULL);
17627 else if (attr_form_is_ref (attr))
17629 struct dwarf2_cu *target_cu = cu;
17630 struct die_info *target_die;
17631 struct attribute *target_attr;
17633 target_die = follow_die_ref (die, attr, &target_cu);
17634 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17635 if (target_attr == NULL)
17636 target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17638 if (target_attr == NULL)
17641 switch (target_attr->name)
17643 case DW_AT_location:
17644 if (attr_form_is_section_offset (target_attr))
17646 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17647 baton->referenced_type = die_type (target_die, target_cu);
17648 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17649 prop->data.baton = baton;
17650 prop->kind = PROP_LOCLIST;
17651 gdb_assert (prop->data.baton != NULL);
17653 else if (attr_form_is_block (target_attr))
17655 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17656 baton->referenced_type = die_type (target_die, target_cu);
17657 baton->locexpr.per_cu = cu->per_cu;
17658 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17659 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17660 prop->data.baton = baton;
17661 prop->kind = PROP_LOCEXPR;
17662 gdb_assert (prop->data.baton != NULL);
17666 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17667 "dynamic property");
17671 case DW_AT_data_member_location:
17675 if (!handle_data_member_location (target_die, target_cu,
17679 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17680 baton->referenced_type = read_type_die (target_die->parent,
17682 baton->offset_info.offset = offset;
17683 baton->offset_info.type = die_type (target_die, target_cu);
17684 prop->data.baton = baton;
17685 prop->kind = PROP_ADDR_OFFSET;
17690 else if (attr_form_is_constant (attr))
17692 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17693 prop->kind = PROP_CONST;
17697 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17698 dwarf2_name (die, cu));
17705 /* Read the given DW_AT_subrange DIE. */
17707 static struct type *
17708 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17710 struct type *base_type, *orig_base_type;
17711 struct type *range_type;
17712 struct attribute *attr;
17713 struct dynamic_prop low, high;
17714 int low_default_is_valid;
17715 int high_bound_is_count = 0;
17717 LONGEST negative_mask;
17719 orig_base_type = die_type (die, cu);
17720 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17721 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17722 creating the range type, but we use the result of check_typedef
17723 when examining properties of the type. */
17724 base_type = check_typedef (orig_base_type);
17726 /* The die_type call above may have already set the type for this DIE. */
17727 range_type = get_die_type (die, cu);
17731 low.kind = PROP_CONST;
17732 high.kind = PROP_CONST;
17733 high.data.const_val = 0;
17735 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17736 omitting DW_AT_lower_bound. */
17737 switch (cu->language)
17740 case language_cplus:
17741 low.data.const_val = 0;
17742 low_default_is_valid = 1;
17744 case language_fortran:
17745 low.data.const_val = 1;
17746 low_default_is_valid = 1;
17749 case language_objc:
17750 case language_rust:
17751 low.data.const_val = 0;
17752 low_default_is_valid = (cu->header.version >= 4);
17756 case language_pascal:
17757 low.data.const_val = 1;
17758 low_default_is_valid = (cu->header.version >= 4);
17761 low.data.const_val = 0;
17762 low_default_is_valid = 0;
17766 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17768 attr_to_dynamic_prop (attr, die, cu, &low);
17769 else if (!low_default_is_valid)
17770 complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
17771 "- DIE at 0x%x [in module %s]"),
17772 to_underlying (die->sect_off),
17773 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17775 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
17776 if (!attr_to_dynamic_prop (attr, die, cu, &high))
17778 attr = dwarf2_attr (die, DW_AT_count, cu);
17779 if (attr_to_dynamic_prop (attr, die, cu, &high))
17781 /* If bounds are constant do the final calculation here. */
17782 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17783 high.data.const_val = low.data.const_val + high.data.const_val - 1;
17785 high_bound_is_count = 1;
17789 /* Dwarf-2 specifications explicitly allows to create subrange types
17790 without specifying a base type.
17791 In that case, the base type must be set to the type of
17792 the lower bound, upper bound or count, in that order, if any of these
17793 three attributes references an object that has a type.
17794 If no base type is found, the Dwarf-2 specifications say that
17795 a signed integer type of size equal to the size of an address should
17797 For the following C code: `extern char gdb_int [];'
17798 GCC produces an empty range DIE.
17799 FIXME: muller/2010-05-28: Possible references to object for low bound,
17800 high bound or count are not yet handled by this code. */
17801 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17803 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17804 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17805 int addr_size = gdbarch_addr_bit (gdbarch) /8;
17806 struct type *int_type = objfile_type (objfile)->builtin_int;
17808 /* Test "int", "long int", and "long long int" objfile types,
17809 and select the first one having a size above or equal to the
17810 architecture address size. */
17811 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17812 base_type = int_type;
17815 int_type = objfile_type (objfile)->builtin_long;
17816 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17817 base_type = int_type;
17820 int_type = objfile_type (objfile)->builtin_long_long;
17821 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17822 base_type = int_type;
17827 /* Normally, the DWARF producers are expected to use a signed
17828 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17829 But this is unfortunately not always the case, as witnessed
17830 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17831 is used instead. To work around that ambiguity, we treat
17832 the bounds as signed, and thus sign-extend their values, when
17833 the base type is signed. */
17835 -((LONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17836 if (low.kind == PROP_CONST
17837 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17838 low.data.const_val |= negative_mask;
17839 if (high.kind == PROP_CONST
17840 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17841 high.data.const_val |= negative_mask;
17843 range_type = create_range_type (NULL, orig_base_type, &low, &high);
17845 if (high_bound_is_count)
17846 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17848 /* Ada expects an empty array on no boundary attributes. */
17849 if (attr == NULL && cu->language != language_ada)
17850 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17852 name = dwarf2_name (die, cu);
17854 TYPE_NAME (range_type) = name;
17856 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17858 TYPE_LENGTH (range_type) = DW_UNSND (attr);
17860 set_die_type (die, range_type, cu);
17862 /* set_die_type should be already done. */
17863 set_descriptive_type (range_type, die, cu);
17868 static struct type *
17869 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17873 type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17875 TYPE_NAME (type) = dwarf2_name (die, cu);
17877 /* In Ada, an unspecified type is typically used when the description
17878 of the type is defered to a different unit. When encountering
17879 such a type, we treat it as a stub, and try to resolve it later on,
17881 if (cu->language == language_ada)
17882 TYPE_STUB (type) = 1;
17884 return set_die_type (die, type, cu);
17887 /* Read a single die and all its descendents. Set the die's sibling
17888 field to NULL; set other fields in the die correctly, and set all
17889 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17890 location of the info_ptr after reading all of those dies. PARENT
17891 is the parent of the die in question. */
17893 static struct die_info *
17894 read_die_and_children (const struct die_reader_specs *reader,
17895 const gdb_byte *info_ptr,
17896 const gdb_byte **new_info_ptr,
17897 struct die_info *parent)
17899 struct die_info *die;
17900 const gdb_byte *cur_ptr;
17903 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17906 *new_info_ptr = cur_ptr;
17909 store_in_ref_table (die, reader->cu);
17912 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17916 *new_info_ptr = cur_ptr;
17919 die->sibling = NULL;
17920 die->parent = parent;
17924 /* Read a die, all of its descendents, and all of its siblings; set
17925 all of the fields of all of the dies correctly. Arguments are as
17926 in read_die_and_children. */
17928 static struct die_info *
17929 read_die_and_siblings_1 (const struct die_reader_specs *reader,
17930 const gdb_byte *info_ptr,
17931 const gdb_byte **new_info_ptr,
17932 struct die_info *parent)
17934 struct die_info *first_die, *last_sibling;
17935 const gdb_byte *cur_ptr;
17937 cur_ptr = info_ptr;
17938 first_die = last_sibling = NULL;
17942 struct die_info *die
17943 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
17947 *new_info_ptr = cur_ptr;
17954 last_sibling->sibling = die;
17956 last_sibling = die;
17960 /* Read a die, all of its descendents, and all of its siblings; set
17961 all of the fields of all of the dies correctly. Arguments are as
17962 in read_die_and_children.
17963 This the main entry point for reading a DIE and all its children. */
17965 static struct die_info *
17966 read_die_and_siblings (const struct die_reader_specs *reader,
17967 const gdb_byte *info_ptr,
17968 const gdb_byte **new_info_ptr,
17969 struct die_info *parent)
17971 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
17972 new_info_ptr, parent);
17974 if (dwarf_die_debug)
17976 fprintf_unfiltered (gdb_stdlog,
17977 "Read die from %s@0x%x of %s:\n",
17978 get_section_name (reader->die_section),
17979 (unsigned) (info_ptr - reader->die_section->buffer),
17980 bfd_get_filename (reader->abfd));
17981 dump_die (die, dwarf_die_debug);
17987 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
17989 The caller is responsible for filling in the extra attributes
17990 and updating (*DIEP)->num_attrs.
17991 Set DIEP to point to a newly allocated die with its information,
17992 except for its child, sibling, and parent fields.
17993 Set HAS_CHILDREN to tell whether the die has children or not. */
17995 static const gdb_byte *
17996 read_full_die_1 (const struct die_reader_specs *reader,
17997 struct die_info **diep, const gdb_byte *info_ptr,
17998 int *has_children, int num_extra_attrs)
18000 unsigned int abbrev_number, bytes_read, i;
18001 struct abbrev_info *abbrev;
18002 struct die_info *die;
18003 struct dwarf2_cu *cu = reader->cu;
18004 bfd *abfd = reader->abfd;
18006 sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18007 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18008 info_ptr += bytes_read;
18009 if (!abbrev_number)
18016 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
18018 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18020 bfd_get_filename (abfd));
18022 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18023 die->sect_off = sect_off;
18024 die->tag = abbrev->tag;
18025 die->abbrev = abbrev_number;
18027 /* Make the result usable.
18028 The caller needs to update num_attrs after adding the extra
18030 die->num_attrs = abbrev->num_attrs;
18032 for (i = 0; i < abbrev->num_attrs; ++i)
18033 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18037 *has_children = abbrev->has_children;
18041 /* Read a die and all its attributes.
18042 Set DIEP to point to a newly allocated die with its information,
18043 except for its child, sibling, and parent fields.
18044 Set HAS_CHILDREN to tell whether the die has children or not. */
18046 static const gdb_byte *
18047 read_full_die (const struct die_reader_specs *reader,
18048 struct die_info **diep, const gdb_byte *info_ptr,
18051 const gdb_byte *result;
18053 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18055 if (dwarf_die_debug)
18057 fprintf_unfiltered (gdb_stdlog,
18058 "Read die from %s@0x%x of %s:\n",
18059 get_section_name (reader->die_section),
18060 (unsigned) (info_ptr - reader->die_section->buffer),
18061 bfd_get_filename (reader->abfd));
18062 dump_die (*diep, dwarf_die_debug);
18068 /* Abbreviation tables.
18070 In DWARF version 2, the description of the debugging information is
18071 stored in a separate .debug_abbrev section. Before we read any
18072 dies from a section we read in all abbreviations and install them
18073 in a hash table. */
18075 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18077 static struct abbrev_info *
18078 abbrev_table_alloc_abbrev (struct abbrev_table *abbrev_table)
18080 struct abbrev_info *abbrev;
18082 abbrev = XOBNEW (&abbrev_table->abbrev_obstack, struct abbrev_info);
18083 memset (abbrev, 0, sizeof (struct abbrev_info));
18088 /* Add an abbreviation to the table. */
18091 abbrev_table_add_abbrev (struct abbrev_table *abbrev_table,
18092 unsigned int abbrev_number,
18093 struct abbrev_info *abbrev)
18095 unsigned int hash_number;
18097 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18098 abbrev->next = abbrev_table->abbrevs[hash_number];
18099 abbrev_table->abbrevs[hash_number] = abbrev;
18102 /* Look up an abbrev in the table.
18103 Returns NULL if the abbrev is not found. */
18105 static struct abbrev_info *
18106 abbrev_table_lookup_abbrev (const struct abbrev_table *abbrev_table,
18107 unsigned int abbrev_number)
18109 unsigned int hash_number;
18110 struct abbrev_info *abbrev;
18112 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18113 abbrev = abbrev_table->abbrevs[hash_number];
18117 if (abbrev->number == abbrev_number)
18119 abbrev = abbrev->next;
18124 /* Read in an abbrev table. */
18126 static struct abbrev_table *
18127 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18128 struct dwarf2_section_info *section,
18129 sect_offset sect_off)
18131 struct objfile *objfile = dwarf2_per_objfile->objfile;
18132 bfd *abfd = get_section_bfd_owner (section);
18133 struct abbrev_table *abbrev_table;
18134 const gdb_byte *abbrev_ptr;
18135 struct abbrev_info *cur_abbrev;
18136 unsigned int abbrev_number, bytes_read, abbrev_name;
18137 unsigned int abbrev_form;
18138 struct attr_abbrev *cur_attrs;
18139 unsigned int allocated_attrs;
18141 abbrev_table = XNEW (struct abbrev_table);
18142 abbrev_table->sect_off = sect_off;
18143 obstack_init (&abbrev_table->abbrev_obstack);
18144 abbrev_table->abbrevs =
18145 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct abbrev_info *,
18147 memset (abbrev_table->abbrevs, 0,
18148 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
18150 dwarf2_read_section (objfile, section);
18151 abbrev_ptr = section->buffer + to_underlying (sect_off);
18152 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18153 abbrev_ptr += bytes_read;
18155 allocated_attrs = ATTR_ALLOC_CHUNK;
18156 cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18158 /* Loop until we reach an abbrev number of 0. */
18159 while (abbrev_number)
18161 cur_abbrev = abbrev_table_alloc_abbrev (abbrev_table);
18163 /* read in abbrev header */
18164 cur_abbrev->number = abbrev_number;
18166 = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18167 abbrev_ptr += bytes_read;
18168 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18171 /* now read in declarations */
18174 LONGEST implicit_const;
18176 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18177 abbrev_ptr += bytes_read;
18178 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18179 abbrev_ptr += bytes_read;
18180 if (abbrev_form == DW_FORM_implicit_const)
18182 implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18184 abbrev_ptr += bytes_read;
18188 /* Initialize it due to a false compiler warning. */
18189 implicit_const = -1;
18192 if (abbrev_name == 0)
18195 if (cur_abbrev->num_attrs == allocated_attrs)
18197 allocated_attrs += ATTR_ALLOC_CHUNK;
18199 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18202 cur_attrs[cur_abbrev->num_attrs].name
18203 = (enum dwarf_attribute) abbrev_name;
18204 cur_attrs[cur_abbrev->num_attrs].form
18205 = (enum dwarf_form) abbrev_form;
18206 cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18207 ++cur_abbrev->num_attrs;
18210 cur_abbrev->attrs =
18211 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18212 cur_abbrev->num_attrs);
18213 memcpy (cur_abbrev->attrs, cur_attrs,
18214 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18216 abbrev_table_add_abbrev (abbrev_table, abbrev_number, cur_abbrev);
18218 /* Get next abbreviation.
18219 Under Irix6 the abbreviations for a compilation unit are not
18220 always properly terminated with an abbrev number of 0.
18221 Exit loop if we encounter an abbreviation which we have
18222 already read (which means we are about to read the abbreviations
18223 for the next compile unit) or if the end of the abbreviation
18224 table is reached. */
18225 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18227 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18228 abbrev_ptr += bytes_read;
18229 if (abbrev_table_lookup_abbrev (abbrev_table, abbrev_number) != NULL)
18234 return abbrev_table;
18237 /* Free the resources held by ABBREV_TABLE. */
18240 abbrev_table_free (struct abbrev_table *abbrev_table)
18242 obstack_free (&abbrev_table->abbrev_obstack, NULL);
18243 xfree (abbrev_table);
18246 /* Same as abbrev_table_free but as a cleanup.
18247 We pass in a pointer to the pointer to the table so that we can
18248 set the pointer to NULL when we're done. It also simplifies
18249 build_type_psymtabs_1. */
18252 abbrev_table_free_cleanup (void *table_ptr)
18254 struct abbrev_table **abbrev_table_ptr = (struct abbrev_table **) table_ptr;
18256 if (*abbrev_table_ptr != NULL)
18257 abbrev_table_free (*abbrev_table_ptr);
18258 *abbrev_table_ptr = NULL;
18261 /* Read the abbrev table for CU from ABBREV_SECTION. */
18264 dwarf2_read_abbrevs (struct dwarf2_cu *cu,
18265 struct dwarf2_section_info *abbrev_section)
18268 abbrev_table_read_table (cu->per_cu->dwarf2_per_objfile, abbrev_section,
18269 cu->header.abbrev_sect_off);
18272 /* Release the memory used by the abbrev table for a compilation unit. */
18275 dwarf2_free_abbrev_table (void *ptr_to_cu)
18277 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr_to_cu;
18279 if (cu->abbrev_table != NULL)
18280 abbrev_table_free (cu->abbrev_table);
18281 /* Set this to NULL so that we SEGV if we try to read it later,
18282 and also because free_comp_unit verifies this is NULL. */
18283 cu->abbrev_table = NULL;
18286 /* Returns nonzero if TAG represents a type that we might generate a partial
18290 is_type_tag_for_partial (int tag)
18295 /* Some types that would be reasonable to generate partial symbols for,
18296 that we don't at present. */
18297 case DW_TAG_array_type:
18298 case DW_TAG_file_type:
18299 case DW_TAG_ptr_to_member_type:
18300 case DW_TAG_set_type:
18301 case DW_TAG_string_type:
18302 case DW_TAG_subroutine_type:
18304 case DW_TAG_base_type:
18305 case DW_TAG_class_type:
18306 case DW_TAG_interface_type:
18307 case DW_TAG_enumeration_type:
18308 case DW_TAG_structure_type:
18309 case DW_TAG_subrange_type:
18310 case DW_TAG_typedef:
18311 case DW_TAG_union_type:
18318 /* Load all DIEs that are interesting for partial symbols into memory. */
18320 static struct partial_die_info *
18321 load_partial_dies (const struct die_reader_specs *reader,
18322 const gdb_byte *info_ptr, int building_psymtab)
18324 struct dwarf2_cu *cu = reader->cu;
18325 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18326 struct partial_die_info *part_die;
18327 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18328 struct abbrev_info *abbrev;
18329 unsigned int bytes_read;
18330 unsigned int load_all = 0;
18331 int nesting_level = 1;
18336 gdb_assert (cu->per_cu != NULL);
18337 if (cu->per_cu->load_all_dies)
18341 = htab_create_alloc_ex (cu->header.length / 12,
18345 &cu->comp_unit_obstack,
18346 hashtab_obstack_allocate,
18347 dummy_obstack_deallocate);
18349 part_die = XOBNEW (&cu->comp_unit_obstack, struct partial_die_info);
18353 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
18355 /* A NULL abbrev means the end of a series of children. */
18356 if (abbrev == NULL)
18358 if (--nesting_level == 0)
18360 /* PART_DIE was probably the last thing allocated on the
18361 comp_unit_obstack, so we could call obstack_free
18362 here. We don't do that because the waste is small,
18363 and will be cleaned up when we're done with this
18364 compilation unit. This way, we're also more robust
18365 against other users of the comp_unit_obstack. */
18368 info_ptr += bytes_read;
18369 last_die = parent_die;
18370 parent_die = parent_die->die_parent;
18374 /* Check for template arguments. We never save these; if
18375 they're seen, we just mark the parent, and go on our way. */
18376 if (parent_die != NULL
18377 && cu->language == language_cplus
18378 && (abbrev->tag == DW_TAG_template_type_param
18379 || abbrev->tag == DW_TAG_template_value_param))
18381 parent_die->has_template_arguments = 1;
18385 /* We don't need a partial DIE for the template argument. */
18386 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18391 /* We only recurse into c++ subprograms looking for template arguments.
18392 Skip their other children. */
18394 && cu->language == language_cplus
18395 && parent_die != NULL
18396 && parent_die->tag == DW_TAG_subprogram)
18398 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18402 /* Check whether this DIE is interesting enough to save. Normally
18403 we would not be interested in members here, but there may be
18404 later variables referencing them via DW_AT_specification (for
18405 static members). */
18407 && !is_type_tag_for_partial (abbrev->tag)
18408 && abbrev->tag != DW_TAG_constant
18409 && abbrev->tag != DW_TAG_enumerator
18410 && abbrev->tag != DW_TAG_subprogram
18411 && abbrev->tag != DW_TAG_inlined_subroutine
18412 && abbrev->tag != DW_TAG_lexical_block
18413 && abbrev->tag != DW_TAG_variable
18414 && abbrev->tag != DW_TAG_namespace
18415 && abbrev->tag != DW_TAG_module
18416 && abbrev->tag != DW_TAG_member
18417 && abbrev->tag != DW_TAG_imported_unit
18418 && abbrev->tag != DW_TAG_imported_declaration)
18420 /* Otherwise we skip to the next sibling, if any. */
18421 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18425 info_ptr = read_partial_die (reader, part_die, abbrev, bytes_read,
18428 /* This two-pass algorithm for processing partial symbols has a
18429 high cost in cache pressure. Thus, handle some simple cases
18430 here which cover the majority of C partial symbols. DIEs
18431 which neither have specification tags in them, nor could have
18432 specification tags elsewhere pointing at them, can simply be
18433 processed and discarded.
18435 This segment is also optional; scan_partial_symbols and
18436 add_partial_symbol will handle these DIEs if we chain
18437 them in normally. When compilers which do not emit large
18438 quantities of duplicate debug information are more common,
18439 this code can probably be removed. */
18441 /* Any complete simple types at the top level (pretty much all
18442 of them, for a language without namespaces), can be processed
18444 if (parent_die == NULL
18445 && part_die->has_specification == 0
18446 && part_die->is_declaration == 0
18447 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
18448 || part_die->tag == DW_TAG_base_type
18449 || part_die->tag == DW_TAG_subrange_type))
18451 if (building_psymtab && part_die->name != NULL)
18452 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
18453 VAR_DOMAIN, LOC_TYPEDEF,
18454 &objfile->static_psymbols,
18455 0, cu->language, objfile);
18456 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
18460 /* The exception for DW_TAG_typedef with has_children above is
18461 a workaround of GCC PR debug/47510. In the case of this complaint
18462 type_name_no_tag_or_error will error on such types later.
18464 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18465 it could not find the child DIEs referenced later, this is checked
18466 above. In correct DWARF DW_TAG_typedef should have no children. */
18468 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
18469 complaint (&symfile_complaints,
18470 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18471 "- DIE at 0x%x [in module %s]"),
18472 to_underlying (part_die->sect_off), objfile_name (objfile));
18474 /* If we're at the second level, and we're an enumerator, and
18475 our parent has no specification (meaning possibly lives in a
18476 namespace elsewhere), then we can add the partial symbol now
18477 instead of queueing it. */
18478 if (part_die->tag == DW_TAG_enumerator
18479 && parent_die != NULL
18480 && parent_die->die_parent == NULL
18481 && parent_die->tag == DW_TAG_enumeration_type
18482 && parent_die->has_specification == 0)
18484 if (part_die->name == NULL)
18485 complaint (&symfile_complaints,
18486 _("malformed enumerator DIE ignored"));
18487 else if (building_psymtab)
18488 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
18489 VAR_DOMAIN, LOC_CONST,
18490 cu->language == language_cplus
18491 ? &objfile->global_psymbols
18492 : &objfile->static_psymbols,
18493 0, cu->language, objfile);
18495 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
18499 /* We'll save this DIE so link it in. */
18500 part_die->die_parent = parent_die;
18501 part_die->die_sibling = NULL;
18502 part_die->die_child = NULL;
18504 if (last_die && last_die == parent_die)
18505 last_die->die_child = part_die;
18507 last_die->die_sibling = part_die;
18509 last_die = part_die;
18511 if (first_die == NULL)
18512 first_die = part_die;
18514 /* Maybe add the DIE to the hash table. Not all DIEs that we
18515 find interesting need to be in the hash table, because we
18516 also have the parent/sibling/child chains; only those that we
18517 might refer to by offset later during partial symbol reading.
18519 For now this means things that might have be the target of a
18520 DW_AT_specification, DW_AT_abstract_origin, or
18521 DW_AT_extension. DW_AT_extension will refer only to
18522 namespaces; DW_AT_abstract_origin refers to functions (and
18523 many things under the function DIE, but we do not recurse
18524 into function DIEs during partial symbol reading) and
18525 possibly variables as well; DW_AT_specification refers to
18526 declarations. Declarations ought to have the DW_AT_declaration
18527 flag. It happens that GCC forgets to put it in sometimes, but
18528 only for functions, not for types.
18530 Adding more things than necessary to the hash table is harmless
18531 except for the performance cost. Adding too few will result in
18532 wasted time in find_partial_die, when we reread the compilation
18533 unit with load_all_dies set. */
18536 || abbrev->tag == DW_TAG_constant
18537 || abbrev->tag == DW_TAG_subprogram
18538 || abbrev->tag == DW_TAG_variable
18539 || abbrev->tag == DW_TAG_namespace
18540 || part_die->is_declaration)
18544 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18545 to_underlying (part_die->sect_off),
18550 part_die = XOBNEW (&cu->comp_unit_obstack, struct partial_die_info);
18552 /* For some DIEs we want to follow their children (if any). For C
18553 we have no reason to follow the children of structures; for other
18554 languages we have to, so that we can get at method physnames
18555 to infer fully qualified class names, for DW_AT_specification,
18556 and for C++ template arguments. For C++, we also look one level
18557 inside functions to find template arguments (if the name of the
18558 function does not already contain the template arguments).
18560 For Ada, we need to scan the children of subprograms and lexical
18561 blocks as well because Ada allows the definition of nested
18562 entities that could be interesting for the debugger, such as
18563 nested subprograms for instance. */
18564 if (last_die->has_children
18566 || last_die->tag == DW_TAG_namespace
18567 || last_die->tag == DW_TAG_module
18568 || last_die->tag == DW_TAG_enumeration_type
18569 || (cu->language == language_cplus
18570 && last_die->tag == DW_TAG_subprogram
18571 && (last_die->name == NULL
18572 || strchr (last_die->name, '<') == NULL))
18573 || (cu->language != language_c
18574 && (last_die->tag == DW_TAG_class_type
18575 || last_die->tag == DW_TAG_interface_type
18576 || last_die->tag == DW_TAG_structure_type
18577 || last_die->tag == DW_TAG_union_type))
18578 || (cu->language == language_ada
18579 && (last_die->tag == DW_TAG_subprogram
18580 || last_die->tag == DW_TAG_lexical_block))))
18583 parent_die = last_die;
18587 /* Otherwise we skip to the next sibling, if any. */
18588 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18590 /* Back to the top, do it again. */
18594 /* Read a minimal amount of information into the minimal die structure. */
18596 static const gdb_byte *
18597 read_partial_die (const struct die_reader_specs *reader,
18598 struct partial_die_info *part_die,
18599 struct abbrev_info *abbrev, unsigned int abbrev_len,
18600 const gdb_byte *info_ptr)
18602 struct dwarf2_cu *cu = reader->cu;
18603 struct dwarf2_per_objfile *dwarf2_per_objfile
18604 = cu->per_cu->dwarf2_per_objfile;
18605 struct objfile *objfile = dwarf2_per_objfile->objfile;
18606 const gdb_byte *buffer = reader->buffer;
18608 struct attribute attr;
18609 int has_low_pc_attr = 0;
18610 int has_high_pc_attr = 0;
18611 int high_pc_relative = 0;
18613 memset (part_die, 0, sizeof (struct partial_die_info));
18615 part_die->sect_off = (sect_offset) (info_ptr - buffer);
18617 info_ptr += abbrev_len;
18619 if (abbrev == NULL)
18622 part_die->tag = abbrev->tag;
18623 part_die->has_children = abbrev->has_children;
18625 for (i = 0; i < abbrev->num_attrs; ++i)
18627 info_ptr = read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
18629 /* Store the data if it is of an attribute we want to keep in a
18630 partial symbol table. */
18634 switch (part_die->tag)
18636 case DW_TAG_compile_unit:
18637 case DW_TAG_partial_unit:
18638 case DW_TAG_type_unit:
18639 /* Compilation units have a DW_AT_name that is a filename, not
18640 a source language identifier. */
18641 case DW_TAG_enumeration_type:
18642 case DW_TAG_enumerator:
18643 /* These tags always have simple identifiers already; no need
18644 to canonicalize them. */
18645 part_die->name = DW_STRING (&attr);
18649 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18650 &objfile->per_bfd->storage_obstack);
18654 case DW_AT_linkage_name:
18655 case DW_AT_MIPS_linkage_name:
18656 /* Note that both forms of linkage name might appear. We
18657 assume they will be the same, and we only store the last
18659 if (cu->language == language_ada)
18660 part_die->name = DW_STRING (&attr);
18661 part_die->linkage_name = DW_STRING (&attr);
18664 has_low_pc_attr = 1;
18665 part_die->lowpc = attr_value_as_address (&attr);
18667 case DW_AT_high_pc:
18668 has_high_pc_attr = 1;
18669 part_die->highpc = attr_value_as_address (&attr);
18670 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18671 high_pc_relative = 1;
18673 case DW_AT_location:
18674 /* Support the .debug_loc offsets. */
18675 if (attr_form_is_block (&attr))
18677 part_die->d.locdesc = DW_BLOCK (&attr);
18679 else if (attr_form_is_section_offset (&attr))
18681 dwarf2_complex_location_expr_complaint ();
18685 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18686 "partial symbol information");
18689 case DW_AT_external:
18690 part_die->is_external = DW_UNSND (&attr);
18692 case DW_AT_declaration:
18693 part_die->is_declaration = DW_UNSND (&attr);
18696 part_die->has_type = 1;
18698 case DW_AT_abstract_origin:
18699 case DW_AT_specification:
18700 case DW_AT_extension:
18701 part_die->has_specification = 1;
18702 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
18703 part_die->spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18704 || cu->per_cu->is_dwz);
18706 case DW_AT_sibling:
18707 /* Ignore absolute siblings, they might point outside of
18708 the current compile unit. */
18709 if (attr.form == DW_FORM_ref_addr)
18710 complaint (&symfile_complaints,
18711 _("ignoring absolute DW_AT_sibling"));
18714 sect_offset off = dwarf2_get_ref_die_offset (&attr);
18715 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18717 if (sibling_ptr < info_ptr)
18718 complaint (&symfile_complaints,
18719 _("DW_AT_sibling points backwards"));
18720 else if (sibling_ptr > reader->buffer_end)
18721 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18723 part_die->sibling = sibling_ptr;
18726 case DW_AT_byte_size:
18727 part_die->has_byte_size = 1;
18729 case DW_AT_const_value:
18730 part_die->has_const_value = 1;
18732 case DW_AT_calling_convention:
18733 /* DWARF doesn't provide a way to identify a program's source-level
18734 entry point. DW_AT_calling_convention attributes are only meant
18735 to describe functions' calling conventions.
18737 However, because it's a necessary piece of information in
18738 Fortran, and before DWARF 4 DW_CC_program was the only
18739 piece of debugging information whose definition refers to
18740 a 'main program' at all, several compilers marked Fortran
18741 main programs with DW_CC_program --- even when those
18742 functions use the standard calling conventions.
18744 Although DWARF now specifies a way to provide this
18745 information, we support this practice for backward
18747 if (DW_UNSND (&attr) == DW_CC_program
18748 && cu->language == language_fortran)
18749 part_die->main_subprogram = 1;
18752 if (DW_UNSND (&attr) == DW_INL_inlined
18753 || DW_UNSND (&attr) == DW_INL_declared_inlined)
18754 part_die->may_be_inlined = 1;
18758 if (part_die->tag == DW_TAG_imported_unit)
18760 part_die->d.sect_off = dwarf2_get_ref_die_offset (&attr);
18761 part_die->is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18762 || cu->per_cu->is_dwz);
18766 case DW_AT_main_subprogram:
18767 part_die->main_subprogram = DW_UNSND (&attr);
18775 if (high_pc_relative)
18776 part_die->highpc += part_die->lowpc;
18778 if (has_low_pc_attr && has_high_pc_attr)
18780 /* When using the GNU linker, .gnu.linkonce. sections are used to
18781 eliminate duplicate copies of functions and vtables and such.
18782 The linker will arbitrarily choose one and discard the others.
18783 The AT_*_pc values for such functions refer to local labels in
18784 these sections. If the section from that file was discarded, the
18785 labels are not in the output, so the relocs get a value of 0.
18786 If this is a discarded function, mark the pc bounds as invalid,
18787 so that GDB will ignore it. */
18788 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18790 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18792 complaint (&symfile_complaints,
18793 _("DW_AT_low_pc %s is zero "
18794 "for DIE at 0x%x [in module %s]"),
18795 paddress (gdbarch, part_die->lowpc),
18796 to_underlying (part_die->sect_off), objfile_name (objfile));
18798 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18799 else if (part_die->lowpc >= part_die->highpc)
18801 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18803 complaint (&symfile_complaints,
18804 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18805 "for DIE at 0x%x [in module %s]"),
18806 paddress (gdbarch, part_die->lowpc),
18807 paddress (gdbarch, part_die->highpc),
18808 to_underlying (part_die->sect_off),
18809 objfile_name (objfile));
18812 part_die->has_pc_info = 1;
18818 /* Find a cached partial DIE at OFFSET in CU. */
18820 static struct partial_die_info *
18821 find_partial_die_in_comp_unit (sect_offset sect_off, struct dwarf2_cu *cu)
18823 struct partial_die_info *lookup_die = NULL;
18824 struct partial_die_info part_die;
18826 part_die.sect_off = sect_off;
18827 lookup_die = ((struct partial_die_info *)
18828 htab_find_with_hash (cu->partial_dies, &part_die,
18829 to_underlying (sect_off)));
18834 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18835 except in the case of .debug_types DIEs which do not reference
18836 outside their CU (they do however referencing other types via
18837 DW_FORM_ref_sig8). */
18839 static struct partial_die_info *
18840 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18842 struct dwarf2_per_objfile *dwarf2_per_objfile
18843 = cu->per_cu->dwarf2_per_objfile;
18844 struct objfile *objfile = dwarf2_per_objfile->objfile;
18845 struct dwarf2_per_cu_data *per_cu = NULL;
18846 struct partial_die_info *pd = NULL;
18848 if (offset_in_dwz == cu->per_cu->is_dwz
18849 && offset_in_cu_p (&cu->header, sect_off))
18851 pd = find_partial_die_in_comp_unit (sect_off, cu);
18854 /* We missed recording what we needed.
18855 Load all dies and try again. */
18856 per_cu = cu->per_cu;
18860 /* TUs don't reference other CUs/TUs (except via type signatures). */
18861 if (cu->per_cu->is_debug_types)
18863 error (_("Dwarf Error: Type Unit at offset 0x%x contains"
18864 " external reference to offset 0x%x [in module %s].\n"),
18865 to_underlying (cu->header.sect_off), to_underlying (sect_off),
18866 bfd_get_filename (objfile->obfd));
18868 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18869 dwarf2_per_objfile);
18871 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18872 load_partial_comp_unit (per_cu);
18874 per_cu->cu->last_used = 0;
18875 pd = find_partial_die_in_comp_unit (sect_off, per_cu->cu);
18878 /* If we didn't find it, and not all dies have been loaded,
18879 load them all and try again. */
18881 if (pd == NULL && per_cu->load_all_dies == 0)
18883 per_cu->load_all_dies = 1;
18885 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18886 THIS_CU->cu may already be in use. So we can't just free it and
18887 replace its DIEs with the ones we read in. Instead, we leave those
18888 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18889 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18891 load_partial_comp_unit (per_cu);
18893 pd = find_partial_die_in_comp_unit (sect_off, per_cu->cu);
18897 internal_error (__FILE__, __LINE__,
18898 _("could not find partial DIE 0x%x "
18899 "in cache [from module %s]\n"),
18900 to_underlying (sect_off), bfd_get_filename (objfile->obfd));
18904 /* See if we can figure out if the class lives in a namespace. We do
18905 this by looking for a member function; its demangled name will
18906 contain namespace info, if there is any. */
18909 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18910 struct dwarf2_cu *cu)
18912 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18913 what template types look like, because the demangler
18914 frequently doesn't give the same name as the debug info. We
18915 could fix this by only using the demangled name to get the
18916 prefix (but see comment in read_structure_type). */
18918 struct partial_die_info *real_pdi;
18919 struct partial_die_info *child_pdi;
18921 /* If this DIE (this DIE's specification, if any) has a parent, then
18922 we should not do this. We'll prepend the parent's fully qualified
18923 name when we create the partial symbol. */
18925 real_pdi = struct_pdi;
18926 while (real_pdi->has_specification)
18927 real_pdi = find_partial_die (real_pdi->spec_offset,
18928 real_pdi->spec_is_dwz, cu);
18930 if (real_pdi->die_parent != NULL)
18933 for (child_pdi = struct_pdi->die_child;
18935 child_pdi = child_pdi->die_sibling)
18937 if (child_pdi->tag == DW_TAG_subprogram
18938 && child_pdi->linkage_name != NULL)
18940 char *actual_class_name
18941 = language_class_name_from_physname (cu->language_defn,
18942 child_pdi->linkage_name);
18943 if (actual_class_name != NULL)
18945 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18948 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18950 strlen (actual_class_name)));
18951 xfree (actual_class_name);
18958 /* Adjust PART_DIE before generating a symbol for it. This function
18959 may set the is_external flag or change the DIE's name. */
18962 fixup_partial_die (struct partial_die_info *part_die,
18963 struct dwarf2_cu *cu)
18965 /* Once we've fixed up a die, there's no point in doing so again.
18966 This also avoids a memory leak if we were to call
18967 guess_partial_die_structure_name multiple times. */
18968 if (part_die->fixup_called)
18971 /* If we found a reference attribute and the DIE has no name, try
18972 to find a name in the referred to DIE. */
18974 if (part_die->name == NULL && part_die->has_specification)
18976 struct partial_die_info *spec_die;
18978 spec_die = find_partial_die (part_die->spec_offset,
18979 part_die->spec_is_dwz, cu);
18981 fixup_partial_die (spec_die, cu);
18983 if (spec_die->name)
18985 part_die->name = spec_die->name;
18987 /* Copy DW_AT_external attribute if it is set. */
18988 if (spec_die->is_external)
18989 part_die->is_external = spec_die->is_external;
18993 /* Set default names for some unnamed DIEs. */
18995 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
18996 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
18998 /* If there is no parent die to provide a namespace, and there are
18999 children, see if we can determine the namespace from their linkage
19001 if (cu->language == language_cplus
19002 && !VEC_empty (dwarf2_section_info_def,
19003 cu->per_cu->dwarf2_per_objfile->types)
19004 && part_die->die_parent == NULL
19005 && part_die->has_children
19006 && (part_die->tag == DW_TAG_class_type
19007 || part_die->tag == DW_TAG_structure_type
19008 || part_die->tag == DW_TAG_union_type))
19009 guess_partial_die_structure_name (part_die, cu);
19011 /* GCC might emit a nameless struct or union that has a linkage
19012 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19013 if (part_die->name == NULL
19014 && (part_die->tag == DW_TAG_class_type
19015 || part_die->tag == DW_TAG_interface_type
19016 || part_die->tag == DW_TAG_structure_type
19017 || part_die->tag == DW_TAG_union_type)
19018 && part_die->linkage_name != NULL)
19022 demangled = gdb_demangle (part_die->linkage_name, DMGL_TYPES);
19027 /* Strip any leading namespaces/classes, keep only the base name.
19028 DW_AT_name for named DIEs does not contain the prefixes. */
19029 base = strrchr (demangled, ':');
19030 if (base && base > demangled && base[-1] == ':')
19035 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19038 obstack_copy0 (&objfile->per_bfd->storage_obstack,
19039 base, strlen (base)));
19044 part_die->fixup_called = 1;
19047 /* Read an attribute value described by an attribute form. */
19049 static const gdb_byte *
19050 read_attribute_value (const struct die_reader_specs *reader,
19051 struct attribute *attr, unsigned form,
19052 LONGEST implicit_const, const gdb_byte *info_ptr)
19054 struct dwarf2_cu *cu = reader->cu;
19055 struct dwarf2_per_objfile *dwarf2_per_objfile
19056 = cu->per_cu->dwarf2_per_objfile;
19057 struct objfile *objfile = dwarf2_per_objfile->objfile;
19058 struct gdbarch *gdbarch = get_objfile_arch (objfile);
19059 bfd *abfd = reader->abfd;
19060 struct comp_unit_head *cu_header = &cu->header;
19061 unsigned int bytes_read;
19062 struct dwarf_block *blk;
19064 attr->form = (enum dwarf_form) form;
19067 case DW_FORM_ref_addr:
19068 if (cu->header.version == 2)
19069 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19071 DW_UNSND (attr) = read_offset (abfd, info_ptr,
19072 &cu->header, &bytes_read);
19073 info_ptr += bytes_read;
19075 case DW_FORM_GNU_ref_alt:
19076 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19077 info_ptr += bytes_read;
19080 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19081 DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19082 info_ptr += bytes_read;
19084 case DW_FORM_block2:
19085 blk = dwarf_alloc_block (cu);
19086 blk->size = read_2_bytes (abfd, info_ptr);
19088 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19089 info_ptr += blk->size;
19090 DW_BLOCK (attr) = blk;
19092 case DW_FORM_block4:
19093 blk = dwarf_alloc_block (cu);
19094 blk->size = read_4_bytes (abfd, info_ptr);
19096 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19097 info_ptr += blk->size;
19098 DW_BLOCK (attr) = blk;
19100 case DW_FORM_data2:
19101 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19104 case DW_FORM_data4:
19105 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19108 case DW_FORM_data8:
19109 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19112 case DW_FORM_data16:
19113 blk = dwarf_alloc_block (cu);
19115 blk->data = read_n_bytes (abfd, info_ptr, 16);
19117 DW_BLOCK (attr) = blk;
19119 case DW_FORM_sec_offset:
19120 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19121 info_ptr += bytes_read;
19123 case DW_FORM_string:
19124 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19125 DW_STRING_IS_CANONICAL (attr) = 0;
19126 info_ptr += bytes_read;
19129 if (!cu->per_cu->is_dwz)
19131 DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19132 abfd, info_ptr, cu_header,
19134 DW_STRING_IS_CANONICAL (attr) = 0;
19135 info_ptr += bytes_read;
19139 case DW_FORM_line_strp:
19140 if (!cu->per_cu->is_dwz)
19142 DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19144 cu_header, &bytes_read);
19145 DW_STRING_IS_CANONICAL (attr) = 0;
19146 info_ptr += bytes_read;
19150 case DW_FORM_GNU_strp_alt:
19152 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19153 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19156 DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19158 DW_STRING_IS_CANONICAL (attr) = 0;
19159 info_ptr += bytes_read;
19162 case DW_FORM_exprloc:
19163 case DW_FORM_block:
19164 blk = dwarf_alloc_block (cu);
19165 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19166 info_ptr += bytes_read;
19167 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19168 info_ptr += blk->size;
19169 DW_BLOCK (attr) = blk;
19171 case DW_FORM_block1:
19172 blk = dwarf_alloc_block (cu);
19173 blk->size = read_1_byte (abfd, info_ptr);
19175 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19176 info_ptr += blk->size;
19177 DW_BLOCK (attr) = blk;
19179 case DW_FORM_data1:
19180 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19184 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19187 case DW_FORM_flag_present:
19188 DW_UNSND (attr) = 1;
19190 case DW_FORM_sdata:
19191 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19192 info_ptr += bytes_read;
19194 case DW_FORM_udata:
19195 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19196 info_ptr += bytes_read;
19199 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19200 + read_1_byte (abfd, info_ptr));
19204 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19205 + read_2_bytes (abfd, info_ptr));
19209 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19210 + read_4_bytes (abfd, info_ptr));
19214 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19215 + read_8_bytes (abfd, info_ptr));
19218 case DW_FORM_ref_sig8:
19219 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19222 case DW_FORM_ref_udata:
19223 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19224 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19225 info_ptr += bytes_read;
19227 case DW_FORM_indirect:
19228 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19229 info_ptr += bytes_read;
19230 if (form == DW_FORM_implicit_const)
19232 implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19233 info_ptr += bytes_read;
19235 info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19238 case DW_FORM_implicit_const:
19239 DW_SND (attr) = implicit_const;
19241 case DW_FORM_GNU_addr_index:
19242 if (reader->dwo_file == NULL)
19244 /* For now flag a hard error.
19245 Later we can turn this into a complaint. */
19246 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19247 dwarf_form_name (form),
19248 bfd_get_filename (abfd));
19250 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19251 info_ptr += bytes_read;
19253 case DW_FORM_GNU_str_index:
19254 if (reader->dwo_file == NULL)
19256 /* For now flag a hard error.
19257 Later we can turn this into a complaint if warranted. */
19258 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19259 dwarf_form_name (form),
19260 bfd_get_filename (abfd));
19263 ULONGEST str_index =
19264 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19266 DW_STRING (attr) = read_str_index (reader, str_index);
19267 DW_STRING_IS_CANONICAL (attr) = 0;
19268 info_ptr += bytes_read;
19272 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19273 dwarf_form_name (form),
19274 bfd_get_filename (abfd));
19278 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19279 attr->form = DW_FORM_GNU_ref_alt;
19281 /* We have seen instances where the compiler tried to emit a byte
19282 size attribute of -1 which ended up being encoded as an unsigned
19283 0xffffffff. Although 0xffffffff is technically a valid size value,
19284 an object of this size seems pretty unlikely so we can relatively
19285 safely treat these cases as if the size attribute was invalid and
19286 treat them as zero by default. */
19287 if (attr->name == DW_AT_byte_size
19288 && form == DW_FORM_data4
19289 && DW_UNSND (attr) >= 0xffffffff)
19292 (&symfile_complaints,
19293 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19294 hex_string (DW_UNSND (attr)));
19295 DW_UNSND (attr) = 0;
19301 /* Read an attribute described by an abbreviated attribute. */
19303 static const gdb_byte *
19304 read_attribute (const struct die_reader_specs *reader,
19305 struct attribute *attr, struct attr_abbrev *abbrev,
19306 const gdb_byte *info_ptr)
19308 attr->name = abbrev->name;
19309 return read_attribute_value (reader, attr, abbrev->form,
19310 abbrev->implicit_const, info_ptr);
19313 /* Read dwarf information from a buffer. */
19315 static unsigned int
19316 read_1_byte (bfd *abfd, const gdb_byte *buf)
19318 return bfd_get_8 (abfd, buf);
19322 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19324 return bfd_get_signed_8 (abfd, buf);
19327 static unsigned int
19328 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19330 return bfd_get_16 (abfd, buf);
19334 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19336 return bfd_get_signed_16 (abfd, buf);
19339 static unsigned int
19340 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19342 return bfd_get_32 (abfd, buf);
19346 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19348 return bfd_get_signed_32 (abfd, buf);
19352 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19354 return bfd_get_64 (abfd, buf);
19358 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19359 unsigned int *bytes_read)
19361 struct comp_unit_head *cu_header = &cu->header;
19362 CORE_ADDR retval = 0;
19364 if (cu_header->signed_addr_p)
19366 switch (cu_header->addr_size)
19369 retval = bfd_get_signed_16 (abfd, buf);
19372 retval = bfd_get_signed_32 (abfd, buf);
19375 retval = bfd_get_signed_64 (abfd, buf);
19378 internal_error (__FILE__, __LINE__,
19379 _("read_address: bad switch, signed [in module %s]"),
19380 bfd_get_filename (abfd));
19385 switch (cu_header->addr_size)
19388 retval = bfd_get_16 (abfd, buf);
19391 retval = bfd_get_32 (abfd, buf);
19394 retval = bfd_get_64 (abfd, buf);
19397 internal_error (__FILE__, __LINE__,
19398 _("read_address: bad switch, "
19399 "unsigned [in module %s]"),
19400 bfd_get_filename (abfd));
19404 *bytes_read = cu_header->addr_size;
19408 /* Read the initial length from a section. The (draft) DWARF 3
19409 specification allows the initial length to take up either 4 bytes
19410 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19411 bytes describe the length and all offsets will be 8 bytes in length
19414 An older, non-standard 64-bit format is also handled by this
19415 function. The older format in question stores the initial length
19416 as an 8-byte quantity without an escape value. Lengths greater
19417 than 2^32 aren't very common which means that the initial 4 bytes
19418 is almost always zero. Since a length value of zero doesn't make
19419 sense for the 32-bit format, this initial zero can be considered to
19420 be an escape value which indicates the presence of the older 64-bit
19421 format. As written, the code can't detect (old format) lengths
19422 greater than 4GB. If it becomes necessary to handle lengths
19423 somewhat larger than 4GB, we could allow other small values (such
19424 as the non-sensical values of 1, 2, and 3) to also be used as
19425 escape values indicating the presence of the old format.
19427 The value returned via bytes_read should be used to increment the
19428 relevant pointer after calling read_initial_length().
19430 [ Note: read_initial_length() and read_offset() are based on the
19431 document entitled "DWARF Debugging Information Format", revision
19432 3, draft 8, dated November 19, 2001. This document was obtained
19435 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19437 This document is only a draft and is subject to change. (So beware.)
19439 Details regarding the older, non-standard 64-bit format were
19440 determined empirically by examining 64-bit ELF files produced by
19441 the SGI toolchain on an IRIX 6.5 machine.
19443 - Kevin, July 16, 2002
19447 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19449 LONGEST length = bfd_get_32 (abfd, buf);
19451 if (length == 0xffffffff)
19453 length = bfd_get_64 (abfd, buf + 4);
19456 else if (length == 0)
19458 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19459 length = bfd_get_64 (abfd, buf);
19470 /* Cover function for read_initial_length.
19471 Returns the length of the object at BUF, and stores the size of the
19472 initial length in *BYTES_READ and stores the size that offsets will be in
19474 If the initial length size is not equivalent to that specified in
19475 CU_HEADER then issue a complaint.
19476 This is useful when reading non-comp-unit headers. */
19479 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19480 const struct comp_unit_head *cu_header,
19481 unsigned int *bytes_read,
19482 unsigned int *offset_size)
19484 LONGEST length = read_initial_length (abfd, buf, bytes_read);
19486 gdb_assert (cu_header->initial_length_size == 4
19487 || cu_header->initial_length_size == 8
19488 || cu_header->initial_length_size == 12);
19490 if (cu_header->initial_length_size != *bytes_read)
19491 complaint (&symfile_complaints,
19492 _("intermixed 32-bit and 64-bit DWARF sections"));
19494 *offset_size = (*bytes_read == 4) ? 4 : 8;
19498 /* Read an offset from the data stream. The size of the offset is
19499 given by cu_header->offset_size. */
19502 read_offset (bfd *abfd, const gdb_byte *buf,
19503 const struct comp_unit_head *cu_header,
19504 unsigned int *bytes_read)
19506 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19508 *bytes_read = cu_header->offset_size;
19512 /* Read an offset from the data stream. */
19515 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19517 LONGEST retval = 0;
19519 switch (offset_size)
19522 retval = bfd_get_32 (abfd, buf);
19525 retval = bfd_get_64 (abfd, buf);
19528 internal_error (__FILE__, __LINE__,
19529 _("read_offset_1: bad switch [in module %s]"),
19530 bfd_get_filename (abfd));
19536 static const gdb_byte *
19537 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19539 /* If the size of a host char is 8 bits, we can return a pointer
19540 to the buffer, otherwise we have to copy the data to a buffer
19541 allocated on the temporary obstack. */
19542 gdb_assert (HOST_CHAR_BIT == 8);
19546 static const char *
19547 read_direct_string (bfd *abfd, const gdb_byte *buf,
19548 unsigned int *bytes_read_ptr)
19550 /* If the size of a host char is 8 bits, we can return a pointer
19551 to the string, otherwise we have to copy the string to a buffer
19552 allocated on the temporary obstack. */
19553 gdb_assert (HOST_CHAR_BIT == 8);
19556 *bytes_read_ptr = 1;
19559 *bytes_read_ptr = strlen ((const char *) buf) + 1;
19560 return (const char *) buf;
19563 /* Return pointer to string at section SECT offset STR_OFFSET with error
19564 reporting strings FORM_NAME and SECT_NAME. */
19566 static const char *
19567 read_indirect_string_at_offset_from (struct objfile *objfile,
19568 bfd *abfd, LONGEST str_offset,
19569 struct dwarf2_section_info *sect,
19570 const char *form_name,
19571 const char *sect_name)
19573 dwarf2_read_section (objfile, sect);
19574 if (sect->buffer == NULL)
19575 error (_("%s used without %s section [in module %s]"),
19576 form_name, sect_name, bfd_get_filename (abfd));
19577 if (str_offset >= sect->size)
19578 error (_("%s pointing outside of %s section [in module %s]"),
19579 form_name, sect_name, bfd_get_filename (abfd));
19580 gdb_assert (HOST_CHAR_BIT == 8);
19581 if (sect->buffer[str_offset] == '\0')
19583 return (const char *) (sect->buffer + str_offset);
19586 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19588 static const char *
19589 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19590 bfd *abfd, LONGEST str_offset)
19592 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19594 &dwarf2_per_objfile->str,
19595 "DW_FORM_strp", ".debug_str");
19598 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19600 static const char *
19601 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19602 bfd *abfd, LONGEST str_offset)
19604 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19606 &dwarf2_per_objfile->line_str,
19607 "DW_FORM_line_strp",
19608 ".debug_line_str");
19611 /* Read a string at offset STR_OFFSET in the .debug_str section from
19612 the .dwz file DWZ. Throw an error if the offset is too large. If
19613 the string consists of a single NUL byte, return NULL; otherwise
19614 return a pointer to the string. */
19616 static const char *
19617 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19618 LONGEST str_offset)
19620 dwarf2_read_section (objfile, &dwz->str);
19622 if (dwz->str.buffer == NULL)
19623 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19624 "section [in module %s]"),
19625 bfd_get_filename (dwz->dwz_bfd));
19626 if (str_offset >= dwz->str.size)
19627 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19628 ".debug_str section [in module %s]"),
19629 bfd_get_filename (dwz->dwz_bfd));
19630 gdb_assert (HOST_CHAR_BIT == 8);
19631 if (dwz->str.buffer[str_offset] == '\0')
19633 return (const char *) (dwz->str.buffer + str_offset);
19636 /* Return pointer to string at .debug_str offset as read from BUF.
19637 BUF is assumed to be in a compilation unit described by CU_HEADER.
19638 Return *BYTES_READ_PTR count of bytes read from BUF. */
19640 static const char *
19641 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19642 const gdb_byte *buf,
19643 const struct comp_unit_head *cu_header,
19644 unsigned int *bytes_read_ptr)
19646 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19648 return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19651 /* Return pointer to string at .debug_line_str offset as read from BUF.
19652 BUF is assumed to be in a compilation unit described by CU_HEADER.
19653 Return *BYTES_READ_PTR count of bytes read from BUF. */
19655 static const char *
19656 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19657 bfd *abfd, const gdb_byte *buf,
19658 const struct comp_unit_head *cu_header,
19659 unsigned int *bytes_read_ptr)
19661 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19663 return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19668 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19669 unsigned int *bytes_read_ptr)
19672 unsigned int num_read;
19674 unsigned char byte;
19681 byte = bfd_get_8 (abfd, buf);
19684 result |= ((ULONGEST) (byte & 127) << shift);
19685 if ((byte & 128) == 0)
19691 *bytes_read_ptr = num_read;
19696 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19697 unsigned int *bytes_read_ptr)
19700 int shift, num_read;
19701 unsigned char byte;
19708 byte = bfd_get_8 (abfd, buf);
19711 result |= ((LONGEST) (byte & 127) << shift);
19713 if ((byte & 128) == 0)
19718 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19719 result |= -(((LONGEST) 1) << shift);
19720 *bytes_read_ptr = num_read;
19724 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19725 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19726 ADDR_SIZE is the size of addresses from the CU header. */
19729 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19730 unsigned int addr_index, ULONGEST addr_base, int addr_size)
19732 struct objfile *objfile = dwarf2_per_objfile->objfile;
19733 bfd *abfd = objfile->obfd;
19734 const gdb_byte *info_ptr;
19736 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19737 if (dwarf2_per_objfile->addr.buffer == NULL)
19738 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19739 objfile_name (objfile));
19740 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19741 error (_("DW_FORM_addr_index pointing outside of "
19742 ".debug_addr section [in module %s]"),
19743 objfile_name (objfile));
19744 info_ptr = (dwarf2_per_objfile->addr.buffer
19745 + addr_base + addr_index * addr_size);
19746 if (addr_size == 4)
19747 return bfd_get_32 (abfd, info_ptr);
19749 return bfd_get_64 (abfd, info_ptr);
19752 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19755 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19757 return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19758 cu->addr_base, cu->header.addr_size);
19761 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19764 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19765 unsigned int *bytes_read)
19767 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19768 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19770 return read_addr_index (cu, addr_index);
19773 /* Data structure to pass results from dwarf2_read_addr_index_reader
19774 back to dwarf2_read_addr_index. */
19776 struct dwarf2_read_addr_index_data
19778 ULONGEST addr_base;
19782 /* die_reader_func for dwarf2_read_addr_index. */
19785 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19786 const gdb_byte *info_ptr,
19787 struct die_info *comp_unit_die,
19791 struct dwarf2_cu *cu = reader->cu;
19792 struct dwarf2_read_addr_index_data *aidata =
19793 (struct dwarf2_read_addr_index_data *) data;
19795 aidata->addr_base = cu->addr_base;
19796 aidata->addr_size = cu->header.addr_size;
19799 /* Given an index in .debug_addr, fetch the value.
19800 NOTE: This can be called during dwarf expression evaluation,
19801 long after the debug information has been read, and thus per_cu->cu
19802 may no longer exist. */
19805 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19806 unsigned int addr_index)
19808 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19809 struct objfile *objfile = dwarf2_per_objfile->objfile;
19810 struct dwarf2_cu *cu = per_cu->cu;
19811 ULONGEST addr_base;
19814 /* We need addr_base and addr_size.
19815 If we don't have PER_CU->cu, we have to get it.
19816 Nasty, but the alternative is storing the needed info in PER_CU,
19817 which at this point doesn't seem justified: it's not clear how frequently
19818 it would get used and it would increase the size of every PER_CU.
19819 Entry points like dwarf2_per_cu_addr_size do a similar thing
19820 so we're not in uncharted territory here.
19821 Alas we need to be a bit more complicated as addr_base is contained
19824 We don't need to read the entire CU(/TU).
19825 We just need the header and top level die.
19827 IWBN to use the aging mechanism to let us lazily later discard the CU.
19828 For now we skip this optimization. */
19832 addr_base = cu->addr_base;
19833 addr_size = cu->header.addr_size;
19837 struct dwarf2_read_addr_index_data aidata;
19839 /* Note: We can't use init_cutu_and_read_dies_simple here,
19840 we need addr_base. */
19841 init_cutu_and_read_dies (per_cu, NULL, 0, 0,
19842 dwarf2_read_addr_index_reader, &aidata);
19843 addr_base = aidata.addr_base;
19844 addr_size = aidata.addr_size;
19847 return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19851 /* Given a DW_FORM_GNU_str_index, fetch the string.
19852 This is only used by the Fission support. */
19854 static const char *
19855 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19857 struct dwarf2_cu *cu = reader->cu;
19858 struct dwarf2_per_objfile *dwarf2_per_objfile
19859 = cu->per_cu->dwarf2_per_objfile;
19860 struct objfile *objfile = dwarf2_per_objfile->objfile;
19861 const char *objf_name = objfile_name (objfile);
19862 bfd *abfd = objfile->obfd;
19863 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19864 struct dwarf2_section_info *str_offsets_section =
19865 &reader->dwo_file->sections.str_offsets;
19866 const gdb_byte *info_ptr;
19867 ULONGEST str_offset;
19868 static const char form_name[] = "DW_FORM_GNU_str_index";
19870 dwarf2_read_section (objfile, str_section);
19871 dwarf2_read_section (objfile, str_offsets_section);
19872 if (str_section->buffer == NULL)
19873 error (_("%s used without .debug_str.dwo section"
19874 " in CU at offset 0x%x [in module %s]"),
19875 form_name, to_underlying (cu->header.sect_off), objf_name);
19876 if (str_offsets_section->buffer == NULL)
19877 error (_("%s used without .debug_str_offsets.dwo section"
19878 " in CU at offset 0x%x [in module %s]"),
19879 form_name, to_underlying (cu->header.sect_off), objf_name);
19880 if (str_index * cu->header.offset_size >= str_offsets_section->size)
19881 error (_("%s pointing outside of .debug_str_offsets.dwo"
19882 " section in CU at offset 0x%x [in module %s]"),
19883 form_name, to_underlying (cu->header.sect_off), objf_name);
19884 info_ptr = (str_offsets_section->buffer
19885 + str_index * cu->header.offset_size);
19886 if (cu->header.offset_size == 4)
19887 str_offset = bfd_get_32 (abfd, info_ptr);
19889 str_offset = bfd_get_64 (abfd, info_ptr);
19890 if (str_offset >= str_section->size)
19891 error (_("Offset from %s pointing outside of"
19892 " .debug_str.dwo section in CU at offset 0x%x [in module %s]"),
19893 form_name, to_underlying (cu->header.sect_off), objf_name);
19894 return (const char *) (str_section->buffer + str_offset);
19897 /* Return the length of an LEB128 number in BUF. */
19900 leb128_size (const gdb_byte *buf)
19902 const gdb_byte *begin = buf;
19908 if ((byte & 128) == 0)
19909 return buf - begin;
19914 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19923 cu->language = language_c;
19926 case DW_LANG_C_plus_plus:
19927 case DW_LANG_C_plus_plus_11:
19928 case DW_LANG_C_plus_plus_14:
19929 cu->language = language_cplus;
19932 cu->language = language_d;
19934 case DW_LANG_Fortran77:
19935 case DW_LANG_Fortran90:
19936 case DW_LANG_Fortran95:
19937 case DW_LANG_Fortran03:
19938 case DW_LANG_Fortran08:
19939 cu->language = language_fortran;
19942 cu->language = language_go;
19944 case DW_LANG_Mips_Assembler:
19945 cu->language = language_asm;
19947 case DW_LANG_Ada83:
19948 case DW_LANG_Ada95:
19949 cu->language = language_ada;
19951 case DW_LANG_Modula2:
19952 cu->language = language_m2;
19954 case DW_LANG_Pascal83:
19955 cu->language = language_pascal;
19958 cu->language = language_objc;
19961 case DW_LANG_Rust_old:
19962 cu->language = language_rust;
19964 case DW_LANG_Cobol74:
19965 case DW_LANG_Cobol85:
19967 cu->language = language_minimal;
19970 cu->language_defn = language_def (cu->language);
19973 /* Return the named attribute or NULL if not there. */
19975 static struct attribute *
19976 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19981 struct attribute *spec = NULL;
19983 for (i = 0; i < die->num_attrs; ++i)
19985 if (die->attrs[i].name == name)
19986 return &die->attrs[i];
19987 if (die->attrs[i].name == DW_AT_specification
19988 || die->attrs[i].name == DW_AT_abstract_origin)
19989 spec = &die->attrs[i];
19995 die = follow_die_ref (die, spec, &cu);
20001 /* Return the named attribute or NULL if not there,
20002 but do not follow DW_AT_specification, etc.
20003 This is for use in contexts where we're reading .debug_types dies.
20004 Following DW_AT_specification, DW_AT_abstract_origin will take us
20005 back up the chain, and we want to go down. */
20007 static struct attribute *
20008 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
20012 for (i = 0; i < die->num_attrs; ++i)
20013 if (die->attrs[i].name == name)
20014 return &die->attrs[i];
20019 /* Return the string associated with a string-typed attribute, or NULL if it
20020 is either not found or is of an incorrect type. */
20022 static const char *
20023 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20025 struct attribute *attr;
20026 const char *str = NULL;
20028 attr = dwarf2_attr (die, name, cu);
20032 if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20033 || attr->form == DW_FORM_string
20034 || attr->form == DW_FORM_GNU_str_index
20035 || attr->form == DW_FORM_GNU_strp_alt)
20036 str = DW_STRING (attr);
20038 complaint (&symfile_complaints,
20039 _("string type expected for attribute %s for "
20040 "DIE at 0x%x in module %s"),
20041 dwarf_attr_name (name), to_underlying (die->sect_off),
20042 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20048 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20049 and holds a non-zero value. This function should only be used for
20050 DW_FORM_flag or DW_FORM_flag_present attributes. */
20053 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20055 struct attribute *attr = dwarf2_attr (die, name, cu);
20057 return (attr && DW_UNSND (attr));
20061 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20063 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20064 which value is non-zero. However, we have to be careful with
20065 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20066 (via dwarf2_flag_true_p) follows this attribute. So we may
20067 end up accidently finding a declaration attribute that belongs
20068 to a different DIE referenced by the specification attribute,
20069 even though the given DIE does not have a declaration attribute. */
20070 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20071 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20074 /* Return the die giving the specification for DIE, if there is
20075 one. *SPEC_CU is the CU containing DIE on input, and the CU
20076 containing the return value on output. If there is no
20077 specification, but there is an abstract origin, that is
20080 static struct die_info *
20081 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20083 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20086 if (spec_attr == NULL)
20087 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20089 if (spec_attr == NULL)
20092 return follow_die_ref (die, spec_attr, spec_cu);
20095 /* Stub for free_line_header to match void * callback types. */
20098 free_line_header_voidp (void *arg)
20100 struct line_header *lh = (struct line_header *) arg;
20106 line_header::add_include_dir (const char *include_dir)
20108 if (dwarf_line_debug >= 2)
20109 fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20110 include_dirs.size () + 1, include_dir);
20112 include_dirs.push_back (include_dir);
20116 line_header::add_file_name (const char *name,
20118 unsigned int mod_time,
20119 unsigned int length)
20121 if (dwarf_line_debug >= 2)
20122 fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20123 (unsigned) file_names.size () + 1, name);
20125 file_names.emplace_back (name, d_index, mod_time, length);
20128 /* A convenience function to find the proper .debug_line section for a CU. */
20130 static struct dwarf2_section_info *
20131 get_debug_line_section (struct dwarf2_cu *cu)
20133 struct dwarf2_section_info *section;
20134 struct dwarf2_per_objfile *dwarf2_per_objfile
20135 = cu->per_cu->dwarf2_per_objfile;
20137 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20139 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20140 section = &cu->dwo_unit->dwo_file->sections.line;
20141 else if (cu->per_cu->is_dwz)
20143 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20145 section = &dwz->line;
20148 section = &dwarf2_per_objfile->line;
20153 /* Read directory or file name entry format, starting with byte of
20154 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20155 entries count and the entries themselves in the described entry
20159 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20160 bfd *abfd, const gdb_byte **bufp,
20161 struct line_header *lh,
20162 const struct comp_unit_head *cu_header,
20163 void (*callback) (struct line_header *lh,
20166 unsigned int mod_time,
20167 unsigned int length))
20169 gdb_byte format_count, formati;
20170 ULONGEST data_count, datai;
20171 const gdb_byte *buf = *bufp;
20172 const gdb_byte *format_header_data;
20173 unsigned int bytes_read;
20175 format_count = read_1_byte (abfd, buf);
20177 format_header_data = buf;
20178 for (formati = 0; formati < format_count; formati++)
20180 read_unsigned_leb128 (abfd, buf, &bytes_read);
20182 read_unsigned_leb128 (abfd, buf, &bytes_read);
20186 data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20188 for (datai = 0; datai < data_count; datai++)
20190 const gdb_byte *format = format_header_data;
20191 struct file_entry fe;
20193 for (formati = 0; formati < format_count; formati++)
20195 ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20196 format += bytes_read;
20198 ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
20199 format += bytes_read;
20201 gdb::optional<const char *> string;
20202 gdb::optional<unsigned int> uint;
20206 case DW_FORM_string:
20207 string.emplace (read_direct_string (abfd, buf, &bytes_read));
20211 case DW_FORM_line_strp:
20212 string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20219 case DW_FORM_data1:
20220 uint.emplace (read_1_byte (abfd, buf));
20224 case DW_FORM_data2:
20225 uint.emplace (read_2_bytes (abfd, buf));
20229 case DW_FORM_data4:
20230 uint.emplace (read_4_bytes (abfd, buf));
20234 case DW_FORM_data8:
20235 uint.emplace (read_8_bytes (abfd, buf));
20239 case DW_FORM_udata:
20240 uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20244 case DW_FORM_block:
20245 /* It is valid only for DW_LNCT_timestamp which is ignored by
20250 switch (content_type)
20253 if (string.has_value ())
20256 case DW_LNCT_directory_index:
20257 if (uint.has_value ())
20258 fe.d_index = (dir_index) *uint;
20260 case DW_LNCT_timestamp:
20261 if (uint.has_value ())
20262 fe.mod_time = *uint;
20265 if (uint.has_value ())
20271 complaint (&symfile_complaints,
20272 _("Unknown format content type %s"),
20273 pulongest (content_type));
20277 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20283 /* Read the statement program header starting at OFFSET in
20284 .debug_line, or .debug_line.dwo. Return a pointer
20285 to a struct line_header, allocated using xmalloc.
20286 Returns NULL if there is a problem reading the header, e.g., if it
20287 has a version we don't understand.
20289 NOTE: the strings in the include directory and file name tables of
20290 the returned object point into the dwarf line section buffer,
20291 and must not be freed. */
20293 static line_header_up
20294 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20296 const gdb_byte *line_ptr;
20297 unsigned int bytes_read, offset_size;
20299 const char *cur_dir, *cur_file;
20300 struct dwarf2_section_info *section;
20302 struct dwarf2_per_objfile *dwarf2_per_objfile
20303 = cu->per_cu->dwarf2_per_objfile;
20305 section = get_debug_line_section (cu);
20306 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20307 if (section->buffer == NULL)
20309 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20310 complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
20312 complaint (&symfile_complaints, _("missing .debug_line section"));
20316 /* We can't do this until we know the section is non-empty.
20317 Only then do we know we have such a section. */
20318 abfd = get_section_bfd_owner (section);
20320 /* Make sure that at least there's room for the total_length field.
20321 That could be 12 bytes long, but we're just going to fudge that. */
20322 if (to_underlying (sect_off) + 4 >= section->size)
20324 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20328 line_header_up lh (new line_header ());
20330 lh->sect_off = sect_off;
20331 lh->offset_in_dwz = cu->per_cu->is_dwz;
20333 line_ptr = section->buffer + to_underlying (sect_off);
20335 /* Read in the header. */
20337 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20338 &bytes_read, &offset_size);
20339 line_ptr += bytes_read;
20340 if (line_ptr + lh->total_length > (section->buffer + section->size))
20342 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20345 lh->statement_program_end = line_ptr + lh->total_length;
20346 lh->version = read_2_bytes (abfd, line_ptr);
20348 if (lh->version > 5)
20350 /* This is a version we don't understand. The format could have
20351 changed in ways we don't handle properly so just punt. */
20352 complaint (&symfile_complaints,
20353 _("unsupported version in .debug_line section"));
20356 if (lh->version >= 5)
20358 gdb_byte segment_selector_size;
20360 /* Skip address size. */
20361 read_1_byte (abfd, line_ptr);
20364 segment_selector_size = read_1_byte (abfd, line_ptr);
20366 if (segment_selector_size != 0)
20368 complaint (&symfile_complaints,
20369 _("unsupported segment selector size %u "
20370 "in .debug_line section"),
20371 segment_selector_size);
20375 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20376 line_ptr += offset_size;
20377 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20379 if (lh->version >= 4)
20381 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20385 lh->maximum_ops_per_instruction = 1;
20387 if (lh->maximum_ops_per_instruction == 0)
20389 lh->maximum_ops_per_instruction = 1;
20390 complaint (&symfile_complaints,
20391 _("invalid maximum_ops_per_instruction "
20392 "in `.debug_line' section"));
20395 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20397 lh->line_base = read_1_signed_byte (abfd, line_ptr);
20399 lh->line_range = read_1_byte (abfd, line_ptr);
20401 lh->opcode_base = read_1_byte (abfd, line_ptr);
20403 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20405 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
20406 for (i = 1; i < lh->opcode_base; ++i)
20408 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20412 if (lh->version >= 5)
20414 /* Read directory table. */
20415 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20417 [] (struct line_header *lh, const char *name,
20418 dir_index d_index, unsigned int mod_time,
20419 unsigned int length)
20421 lh->add_include_dir (name);
20424 /* Read file name table. */
20425 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20427 [] (struct line_header *lh, const char *name,
20428 dir_index d_index, unsigned int mod_time,
20429 unsigned int length)
20431 lh->add_file_name (name, d_index, mod_time, length);
20436 /* Read directory table. */
20437 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20439 line_ptr += bytes_read;
20440 lh->add_include_dir (cur_dir);
20442 line_ptr += bytes_read;
20444 /* Read file name table. */
20445 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20447 unsigned int mod_time, length;
20450 line_ptr += bytes_read;
20451 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20452 line_ptr += bytes_read;
20453 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20454 line_ptr += bytes_read;
20455 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20456 line_ptr += bytes_read;
20458 lh->add_file_name (cur_file, d_index, mod_time, length);
20460 line_ptr += bytes_read;
20462 lh->statement_program_start = line_ptr;
20464 if (line_ptr > (section->buffer + section->size))
20465 complaint (&symfile_complaints,
20466 _("line number info header doesn't "
20467 "fit in `.debug_line' section"));
20472 /* Subroutine of dwarf_decode_lines to simplify it.
20473 Return the file name of the psymtab for included file FILE_INDEX
20474 in line header LH of PST.
20475 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20476 If space for the result is malloc'd, it will be freed by a cleanup.
20477 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
20479 The function creates dangling cleanup registration. */
20481 static const char *
20482 psymtab_include_file_name (const struct line_header *lh, int file_index,
20483 const struct partial_symtab *pst,
20484 const char *comp_dir)
20486 const file_entry &fe = lh->file_names[file_index];
20487 const char *include_name = fe.name;
20488 const char *include_name_to_compare = include_name;
20489 const char *pst_filename;
20490 char *copied_name = NULL;
20493 const char *dir_name = fe.include_dir (lh);
20495 if (!IS_ABSOLUTE_PATH (include_name)
20496 && (dir_name != NULL || comp_dir != NULL))
20498 /* Avoid creating a duplicate psymtab for PST.
20499 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20500 Before we do the comparison, however, we need to account
20501 for DIR_NAME and COMP_DIR.
20502 First prepend dir_name (if non-NULL). If we still don't
20503 have an absolute path prepend comp_dir (if non-NULL).
20504 However, the directory we record in the include-file's
20505 psymtab does not contain COMP_DIR (to match the
20506 corresponding symtab(s)).
20511 bash$ gcc -g ./hello.c
20512 include_name = "hello.c"
20514 DW_AT_comp_dir = comp_dir = "/tmp"
20515 DW_AT_name = "./hello.c"
20519 if (dir_name != NULL)
20521 char *tem = concat (dir_name, SLASH_STRING,
20522 include_name, (char *)NULL);
20524 make_cleanup (xfree, tem);
20525 include_name = tem;
20526 include_name_to_compare = include_name;
20528 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20530 char *tem = concat (comp_dir, SLASH_STRING,
20531 include_name, (char *)NULL);
20533 make_cleanup (xfree, tem);
20534 include_name_to_compare = tem;
20538 pst_filename = pst->filename;
20539 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20541 copied_name = concat (pst->dirname, SLASH_STRING,
20542 pst_filename, (char *)NULL);
20543 pst_filename = copied_name;
20546 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20548 if (copied_name != NULL)
20549 xfree (copied_name);
20553 return include_name;
20556 /* State machine to track the state of the line number program. */
20558 class lnp_state_machine
20561 /* Initialize a machine state for the start of a line number
20563 lnp_state_machine (gdbarch *arch, line_header *lh, bool record_lines_p);
20565 file_entry *current_file ()
20567 /* lh->file_names is 0-based, but the file name numbers in the
20568 statement program are 1-based. */
20569 return m_line_header->file_name_at (m_file);
20572 /* Record the line in the state machine. END_SEQUENCE is true if
20573 we're processing the end of a sequence. */
20574 void record_line (bool end_sequence);
20576 /* Check address and if invalid nop-out the rest of the lines in this
20578 void check_line_address (struct dwarf2_cu *cu,
20579 const gdb_byte *line_ptr,
20580 CORE_ADDR lowpc, CORE_ADDR address);
20582 void handle_set_discriminator (unsigned int discriminator)
20584 m_discriminator = discriminator;
20585 m_line_has_non_zero_discriminator |= discriminator != 0;
20588 /* Handle DW_LNE_set_address. */
20589 void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20592 address += baseaddr;
20593 m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20596 /* Handle DW_LNS_advance_pc. */
20597 void handle_advance_pc (CORE_ADDR adjust);
20599 /* Handle a special opcode. */
20600 void handle_special_opcode (unsigned char op_code);
20602 /* Handle DW_LNS_advance_line. */
20603 void handle_advance_line (int line_delta)
20605 advance_line (line_delta);
20608 /* Handle DW_LNS_set_file. */
20609 void handle_set_file (file_name_index file);
20611 /* Handle DW_LNS_negate_stmt. */
20612 void handle_negate_stmt ()
20614 m_is_stmt = !m_is_stmt;
20617 /* Handle DW_LNS_const_add_pc. */
20618 void handle_const_add_pc ();
20620 /* Handle DW_LNS_fixed_advance_pc. */
20621 void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20623 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20627 /* Handle DW_LNS_copy. */
20628 void handle_copy ()
20630 record_line (false);
20631 m_discriminator = 0;
20634 /* Handle DW_LNE_end_sequence. */
20635 void handle_end_sequence ()
20637 m_record_line_callback = ::record_line;
20641 /* Advance the line by LINE_DELTA. */
20642 void advance_line (int line_delta)
20644 m_line += line_delta;
20646 if (line_delta != 0)
20647 m_line_has_non_zero_discriminator = m_discriminator != 0;
20650 gdbarch *m_gdbarch;
20652 /* True if we're recording lines.
20653 Otherwise we're building partial symtabs and are just interested in
20654 finding include files mentioned by the line number program. */
20655 bool m_record_lines_p;
20657 /* The line number header. */
20658 line_header *m_line_header;
20660 /* These are part of the standard DWARF line number state machine,
20661 and initialized according to the DWARF spec. */
20663 unsigned char m_op_index = 0;
20664 /* The line table index (1-based) of the current file. */
20665 file_name_index m_file = (file_name_index) 1;
20666 unsigned int m_line = 1;
20668 /* These are initialized in the constructor. */
20670 CORE_ADDR m_address;
20672 unsigned int m_discriminator;
20674 /* Additional bits of state we need to track. */
20676 /* The last file that we called dwarf2_start_subfile for.
20677 This is only used for TLLs. */
20678 unsigned int m_last_file = 0;
20679 /* The last file a line number was recorded for. */
20680 struct subfile *m_last_subfile = NULL;
20682 /* The function to call to record a line. */
20683 record_line_ftype *m_record_line_callback = NULL;
20685 /* The last line number that was recorded, used to coalesce
20686 consecutive entries for the same line. This can happen, for
20687 example, when discriminators are present. PR 17276. */
20688 unsigned int m_last_line = 0;
20689 bool m_line_has_non_zero_discriminator = false;
20693 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20695 CORE_ADDR addr_adj = (((m_op_index + adjust)
20696 / m_line_header->maximum_ops_per_instruction)
20697 * m_line_header->minimum_instruction_length);
20698 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20699 m_op_index = ((m_op_index + adjust)
20700 % m_line_header->maximum_ops_per_instruction);
20704 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20706 unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20707 CORE_ADDR addr_adj = (((m_op_index
20708 + (adj_opcode / m_line_header->line_range))
20709 / m_line_header->maximum_ops_per_instruction)
20710 * m_line_header->minimum_instruction_length);
20711 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20712 m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20713 % m_line_header->maximum_ops_per_instruction);
20715 int line_delta = (m_line_header->line_base
20716 + (adj_opcode % m_line_header->line_range));
20717 advance_line (line_delta);
20718 record_line (false);
20719 m_discriminator = 0;
20723 lnp_state_machine::handle_set_file (file_name_index file)
20727 const file_entry *fe = current_file ();
20729 dwarf2_debug_line_missing_file_complaint ();
20730 else if (m_record_lines_p)
20732 const char *dir = fe->include_dir (m_line_header);
20734 m_last_subfile = current_subfile;
20735 m_line_has_non_zero_discriminator = m_discriminator != 0;
20736 dwarf2_start_subfile (fe->name, dir);
20741 lnp_state_machine::handle_const_add_pc ()
20744 = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20747 = (((m_op_index + adjust)
20748 / m_line_header->maximum_ops_per_instruction)
20749 * m_line_header->minimum_instruction_length);
20751 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20752 m_op_index = ((m_op_index + adjust)
20753 % m_line_header->maximum_ops_per_instruction);
20756 /* Ignore this record_line request. */
20759 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
20764 /* Return non-zero if we should add LINE to the line number table.
20765 LINE is the line to add, LAST_LINE is the last line that was added,
20766 LAST_SUBFILE is the subfile for LAST_LINE.
20767 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20768 had a non-zero discriminator.
20770 We have to be careful in the presence of discriminators.
20771 E.g., for this line:
20773 for (i = 0; i < 100000; i++);
20775 clang can emit four line number entries for that one line,
20776 each with a different discriminator.
20777 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20779 However, we want gdb to coalesce all four entries into one.
20780 Otherwise the user could stepi into the middle of the line and
20781 gdb would get confused about whether the pc really was in the
20782 middle of the line.
20784 Things are further complicated by the fact that two consecutive
20785 line number entries for the same line is a heuristic used by gcc
20786 to denote the end of the prologue. So we can't just discard duplicate
20787 entries, we have to be selective about it. The heuristic we use is
20788 that we only collapse consecutive entries for the same line if at least
20789 one of those entries has a non-zero discriminator. PR 17276.
20791 Note: Addresses in the line number state machine can never go backwards
20792 within one sequence, thus this coalescing is ok. */
20795 dwarf_record_line_p (unsigned int line, unsigned int last_line,
20796 int line_has_non_zero_discriminator,
20797 struct subfile *last_subfile)
20799 if (current_subfile != last_subfile)
20801 if (line != last_line)
20803 /* Same line for the same file that we've seen already.
20804 As a last check, for pr 17276, only record the line if the line
20805 has never had a non-zero discriminator. */
20806 if (!line_has_non_zero_discriminator)
20811 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
20812 in the line table of subfile SUBFILE. */
20815 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20816 unsigned int line, CORE_ADDR address,
20817 record_line_ftype p_record_line)
20819 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20821 if (dwarf_line_debug)
20823 fprintf_unfiltered (gdb_stdlog,
20824 "Recording line %u, file %s, address %s\n",
20825 line, lbasename (subfile->name),
20826 paddress (gdbarch, address));
20829 (*p_record_line) (subfile, line, addr);
20832 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20833 Mark the end of a set of line number records.
20834 The arguments are the same as for dwarf_record_line_1.
20835 If SUBFILE is NULL the request is ignored. */
20838 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20839 CORE_ADDR address, record_line_ftype p_record_line)
20841 if (subfile == NULL)
20844 if (dwarf_line_debug)
20846 fprintf_unfiltered (gdb_stdlog,
20847 "Finishing current line, file %s, address %s\n",
20848 lbasename (subfile->name),
20849 paddress (gdbarch, address));
20852 dwarf_record_line_1 (gdbarch, subfile, 0, address, p_record_line);
20856 lnp_state_machine::record_line (bool end_sequence)
20858 if (dwarf_line_debug)
20860 fprintf_unfiltered (gdb_stdlog,
20861 "Processing actual line %u: file %u,"
20862 " address %s, is_stmt %u, discrim %u\n",
20863 m_line, to_underlying (m_file),
20864 paddress (m_gdbarch, m_address),
20865 m_is_stmt, m_discriminator);
20868 file_entry *fe = current_file ();
20871 dwarf2_debug_line_missing_file_complaint ();
20872 /* For now we ignore lines not starting on an instruction boundary.
20873 But not when processing end_sequence for compatibility with the
20874 previous version of the code. */
20875 else if (m_op_index == 0 || end_sequence)
20877 fe->included_p = 1;
20878 if (m_record_lines_p && m_is_stmt)
20880 if (m_last_subfile != current_subfile || end_sequence)
20882 dwarf_finish_line (m_gdbarch, m_last_subfile,
20883 m_address, m_record_line_callback);
20888 if (dwarf_record_line_p (m_line, m_last_line,
20889 m_line_has_non_zero_discriminator,
20892 dwarf_record_line_1 (m_gdbarch, current_subfile,
20894 m_record_line_callback);
20896 m_last_subfile = current_subfile;
20897 m_last_line = m_line;
20903 lnp_state_machine::lnp_state_machine (gdbarch *arch, line_header *lh,
20904 bool record_lines_p)
20907 m_record_lines_p = record_lines_p;
20908 m_line_header = lh;
20910 m_record_line_callback = ::record_line;
20912 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20913 was a line entry for it so that the backend has a chance to adjust it
20914 and also record it in case it needs it. This is currently used by MIPS
20915 code, cf. `mips_adjust_dwarf2_line'. */
20916 m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20917 m_is_stmt = lh->default_is_stmt;
20918 m_discriminator = 0;
20922 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20923 const gdb_byte *line_ptr,
20924 CORE_ADDR lowpc, CORE_ADDR address)
20926 /* If address < lowpc then it's not a usable value, it's outside the
20927 pc range of the CU. However, we restrict the test to only address
20928 values of zero to preserve GDB's previous behaviour which is to
20929 handle the specific case of a function being GC'd by the linker. */
20931 if (address == 0 && address < lowpc)
20933 /* This line table is for a function which has been
20934 GCd by the linker. Ignore it. PR gdb/12528 */
20936 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20937 long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20939 complaint (&symfile_complaints,
20940 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20941 line_offset, objfile_name (objfile));
20942 m_record_line_callback = noop_record_line;
20943 /* Note: record_line_callback is left as noop_record_line until
20944 we see DW_LNE_end_sequence. */
20948 /* Subroutine of dwarf_decode_lines to simplify it.
20949 Process the line number information in LH.
20950 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20951 program in order to set included_p for every referenced header. */
20954 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20955 const int decode_for_pst_p, CORE_ADDR lowpc)
20957 const gdb_byte *line_ptr, *extended_end;
20958 const gdb_byte *line_end;
20959 unsigned int bytes_read, extended_len;
20960 unsigned char op_code, extended_op;
20961 CORE_ADDR baseaddr;
20962 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20963 bfd *abfd = objfile->obfd;
20964 struct gdbarch *gdbarch = get_objfile_arch (objfile);
20965 /* True if we're recording line info (as opposed to building partial
20966 symtabs and just interested in finding include files mentioned by
20967 the line number program). */
20968 bool record_lines_p = !decode_for_pst_p;
20970 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20972 line_ptr = lh->statement_program_start;
20973 line_end = lh->statement_program_end;
20975 /* Read the statement sequences until there's nothing left. */
20976 while (line_ptr < line_end)
20978 /* The DWARF line number program state machine. Reset the state
20979 machine at the start of each sequence. */
20980 lnp_state_machine state_machine (gdbarch, lh, record_lines_p);
20981 bool end_sequence = false;
20983 if (record_lines_p)
20985 /* Start a subfile for the current file of the state
20987 const file_entry *fe = state_machine.current_file ();
20990 dwarf2_start_subfile (fe->name, fe->include_dir (lh));
20993 /* Decode the table. */
20994 while (line_ptr < line_end && !end_sequence)
20996 op_code = read_1_byte (abfd, line_ptr);
20999 if (op_code >= lh->opcode_base)
21001 /* Special opcode. */
21002 state_machine.handle_special_opcode (op_code);
21004 else switch (op_code)
21006 case DW_LNS_extended_op:
21007 extended_len = read_unsigned_leb128 (abfd, line_ptr,
21009 line_ptr += bytes_read;
21010 extended_end = line_ptr + extended_len;
21011 extended_op = read_1_byte (abfd, line_ptr);
21013 switch (extended_op)
21015 case DW_LNE_end_sequence:
21016 state_machine.handle_end_sequence ();
21017 end_sequence = true;
21019 case DW_LNE_set_address:
21022 = read_address (abfd, line_ptr, cu, &bytes_read);
21023 line_ptr += bytes_read;
21025 state_machine.check_line_address (cu, line_ptr,
21027 state_machine.handle_set_address (baseaddr, address);
21030 case DW_LNE_define_file:
21032 const char *cur_file;
21033 unsigned int mod_time, length;
21036 cur_file = read_direct_string (abfd, line_ptr,
21038 line_ptr += bytes_read;
21039 dindex = (dir_index)
21040 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21041 line_ptr += bytes_read;
21043 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21044 line_ptr += bytes_read;
21046 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21047 line_ptr += bytes_read;
21048 lh->add_file_name (cur_file, dindex, mod_time, length);
21051 case DW_LNE_set_discriminator:
21053 /* The discriminator is not interesting to the
21054 debugger; just ignore it. We still need to
21055 check its value though:
21056 if there are consecutive entries for the same
21057 (non-prologue) line we want to coalesce them.
21060 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21061 line_ptr += bytes_read;
21063 state_machine.handle_set_discriminator (discr);
21067 complaint (&symfile_complaints,
21068 _("mangled .debug_line section"));
21071 /* Make sure that we parsed the extended op correctly. If e.g.
21072 we expected a different address size than the producer used,
21073 we may have read the wrong number of bytes. */
21074 if (line_ptr != extended_end)
21076 complaint (&symfile_complaints,
21077 _("mangled .debug_line section"));
21082 state_machine.handle_copy ();
21084 case DW_LNS_advance_pc:
21087 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21088 line_ptr += bytes_read;
21090 state_machine.handle_advance_pc (adjust);
21093 case DW_LNS_advance_line:
21096 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21097 line_ptr += bytes_read;
21099 state_machine.handle_advance_line (line_delta);
21102 case DW_LNS_set_file:
21104 file_name_index file
21105 = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21107 line_ptr += bytes_read;
21109 state_machine.handle_set_file (file);
21112 case DW_LNS_set_column:
21113 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21114 line_ptr += bytes_read;
21116 case DW_LNS_negate_stmt:
21117 state_machine.handle_negate_stmt ();
21119 case DW_LNS_set_basic_block:
21121 /* Add to the address register of the state machine the
21122 address increment value corresponding to special opcode
21123 255. I.e., this value is scaled by the minimum
21124 instruction length since special opcode 255 would have
21125 scaled the increment. */
21126 case DW_LNS_const_add_pc:
21127 state_machine.handle_const_add_pc ();
21129 case DW_LNS_fixed_advance_pc:
21131 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21134 state_machine.handle_fixed_advance_pc (addr_adj);
21139 /* Unknown standard opcode, ignore it. */
21142 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21144 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21145 line_ptr += bytes_read;
21152 dwarf2_debug_line_missing_end_sequence_complaint ();
21154 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21155 in which case we still finish recording the last line). */
21156 state_machine.record_line (true);
21160 /* Decode the Line Number Program (LNP) for the given line_header
21161 structure and CU. The actual information extracted and the type
21162 of structures created from the LNP depends on the value of PST.
21164 1. If PST is NULL, then this procedure uses the data from the program
21165 to create all necessary symbol tables, and their linetables.
21167 2. If PST is not NULL, this procedure reads the program to determine
21168 the list of files included by the unit represented by PST, and
21169 builds all the associated partial symbol tables.
21171 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21172 It is used for relative paths in the line table.
21173 NOTE: When processing partial symtabs (pst != NULL),
21174 comp_dir == pst->dirname.
21176 NOTE: It is important that psymtabs have the same file name (via strcmp)
21177 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21178 symtab we don't use it in the name of the psymtabs we create.
21179 E.g. expand_line_sal requires this when finding psymtabs to expand.
21180 A good testcase for this is mb-inline.exp.
21182 LOWPC is the lowest address in CU (or 0 if not known).
21184 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21185 for its PC<->lines mapping information. Otherwise only the filename
21186 table is read in. */
21189 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21190 struct dwarf2_cu *cu, struct partial_symtab *pst,
21191 CORE_ADDR lowpc, int decode_mapping)
21193 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21194 const int decode_for_pst_p = (pst != NULL);
21196 if (decode_mapping)
21197 dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21199 if (decode_for_pst_p)
21203 /* Now that we're done scanning the Line Header Program, we can
21204 create the psymtab of each included file. */
21205 for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21206 if (lh->file_names[file_index].included_p == 1)
21208 const char *include_name =
21209 psymtab_include_file_name (lh, file_index, pst, comp_dir);
21210 if (include_name != NULL)
21211 dwarf2_create_include_psymtab (include_name, pst, objfile);
21216 /* Make sure a symtab is created for every file, even files
21217 which contain only variables (i.e. no code with associated
21219 struct compunit_symtab *cust = buildsym_compunit_symtab ();
21222 for (i = 0; i < lh->file_names.size (); i++)
21224 file_entry &fe = lh->file_names[i];
21226 dwarf2_start_subfile (fe.name, fe.include_dir (lh));
21228 if (current_subfile->symtab == NULL)
21230 current_subfile->symtab
21231 = allocate_symtab (cust, current_subfile->name);
21233 fe.symtab = current_subfile->symtab;
21238 /* Start a subfile for DWARF. FILENAME is the name of the file and
21239 DIRNAME the name of the source directory which contains FILENAME
21240 or NULL if not known.
21241 This routine tries to keep line numbers from identical absolute and
21242 relative file names in a common subfile.
21244 Using the `list' example from the GDB testsuite, which resides in
21245 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21246 of /srcdir/list0.c yields the following debugging information for list0.c:
21248 DW_AT_name: /srcdir/list0.c
21249 DW_AT_comp_dir: /compdir
21250 files.files[0].name: list0.h
21251 files.files[0].dir: /srcdir
21252 files.files[1].name: list0.c
21253 files.files[1].dir: /srcdir
21255 The line number information for list0.c has to end up in a single
21256 subfile, so that `break /srcdir/list0.c:1' works as expected.
21257 start_subfile will ensure that this happens provided that we pass the
21258 concatenation of files.files[1].dir and files.files[1].name as the
21262 dwarf2_start_subfile (const char *filename, const char *dirname)
21266 /* In order not to lose the line information directory,
21267 we concatenate it to the filename when it makes sense.
21268 Note that the Dwarf3 standard says (speaking of filenames in line
21269 information): ``The directory index is ignored for file names
21270 that represent full path names''. Thus ignoring dirname in the
21271 `else' branch below isn't an issue. */
21273 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21275 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21279 start_subfile (filename);
21285 /* Start a symtab for DWARF.
21286 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
21288 static struct compunit_symtab *
21289 dwarf2_start_symtab (struct dwarf2_cu *cu,
21290 const char *name, const char *comp_dir, CORE_ADDR low_pc)
21292 struct compunit_symtab *cust
21293 = start_symtab (cu->per_cu->dwarf2_per_objfile->objfile, name, comp_dir,
21294 low_pc, cu->language);
21296 record_debugformat ("DWARF 2");
21297 record_producer (cu->producer);
21299 /* We assume that we're processing GCC output. */
21300 processing_gcc_compilation = 2;
21302 cu->processing_has_namespace_info = 0;
21308 var_decode_location (struct attribute *attr, struct symbol *sym,
21309 struct dwarf2_cu *cu)
21311 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21312 struct comp_unit_head *cu_header = &cu->header;
21314 /* NOTE drow/2003-01-30: There used to be a comment and some special
21315 code here to turn a symbol with DW_AT_external and a
21316 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21317 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21318 with some versions of binutils) where shared libraries could have
21319 relocations against symbols in their debug information - the
21320 minimal symbol would have the right address, but the debug info
21321 would not. It's no longer necessary, because we will explicitly
21322 apply relocations when we read in the debug information now. */
21324 /* A DW_AT_location attribute with no contents indicates that a
21325 variable has been optimized away. */
21326 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21328 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21332 /* Handle one degenerate form of location expression specially, to
21333 preserve GDB's previous behavior when section offsets are
21334 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21335 then mark this symbol as LOC_STATIC. */
21337 if (attr_form_is_block (attr)
21338 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21339 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21340 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21341 && (DW_BLOCK (attr)->size
21342 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21344 unsigned int dummy;
21346 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21347 SYMBOL_VALUE_ADDRESS (sym) =
21348 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21350 SYMBOL_VALUE_ADDRESS (sym) =
21351 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21352 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21353 fixup_symbol_section (sym, objfile);
21354 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21355 SYMBOL_SECTION (sym));
21359 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21360 expression evaluator, and use LOC_COMPUTED only when necessary
21361 (i.e. when the value of a register or memory location is
21362 referenced, or a thread-local block, etc.). Then again, it might
21363 not be worthwhile. I'm assuming that it isn't unless performance
21364 or memory numbers show me otherwise. */
21366 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21368 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21369 cu->has_loclist = 1;
21372 /* Given a pointer to a DWARF information entry, figure out if we need
21373 to make a symbol table entry for it, and if so, create a new entry
21374 and return a pointer to it.
21375 If TYPE is NULL, determine symbol type from the die, otherwise
21376 used the passed type.
21377 If SPACE is not NULL, use it to hold the new symbol. If it is
21378 NULL, allocate a new symbol on the objfile's obstack. */
21380 static struct symbol *
21381 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21382 struct symbol *space)
21384 struct dwarf2_per_objfile *dwarf2_per_objfile
21385 = cu->per_cu->dwarf2_per_objfile;
21386 struct objfile *objfile = dwarf2_per_objfile->objfile;
21387 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21388 struct symbol *sym = NULL;
21390 struct attribute *attr = NULL;
21391 struct attribute *attr2 = NULL;
21392 CORE_ADDR baseaddr;
21393 struct pending **list_to_add = NULL;
21395 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21397 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21399 name = dwarf2_name (die, cu);
21402 const char *linkagename;
21403 int suppress_add = 0;
21408 sym = allocate_symbol (objfile);
21409 OBJSTAT (objfile, n_syms++);
21411 /* Cache this symbol's name and the name's demangled form (if any). */
21412 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21413 linkagename = dwarf2_physname (name, die, cu);
21414 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21416 /* Fortran does not have mangling standard and the mangling does differ
21417 between gfortran, iFort etc. */
21418 if (cu->language == language_fortran
21419 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21420 symbol_set_demangled_name (&(sym->ginfo),
21421 dwarf2_full_name (name, die, cu),
21424 /* Default assumptions.
21425 Use the passed type or decode it from the die. */
21426 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21427 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21429 SYMBOL_TYPE (sym) = type;
21431 SYMBOL_TYPE (sym) = die_type (die, cu);
21432 attr = dwarf2_attr (die,
21433 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21437 SYMBOL_LINE (sym) = DW_UNSND (attr);
21440 attr = dwarf2_attr (die,
21441 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21445 file_name_index file_index = (file_name_index) DW_UNSND (attr);
21446 struct file_entry *fe;
21448 if (cu->line_header != NULL)
21449 fe = cu->line_header->file_name_at (file_index);
21454 complaint (&symfile_complaints,
21455 _("file index out of range"));
21457 symbol_set_symtab (sym, fe->symtab);
21463 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21468 addr = attr_value_as_address (attr);
21469 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21470 SYMBOL_VALUE_ADDRESS (sym) = addr;
21472 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21473 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21474 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21475 add_symbol_to_list (sym, cu->list_in_scope);
21477 case DW_TAG_subprogram:
21478 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21480 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21481 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21482 if ((attr2 && (DW_UNSND (attr2) != 0))
21483 || cu->language == language_ada)
21485 /* Subprograms marked external are stored as a global symbol.
21486 Ada subprograms, whether marked external or not, are always
21487 stored as a global symbol, because we want to be able to
21488 access them globally. For instance, we want to be able
21489 to break on a nested subprogram without having to
21490 specify the context. */
21491 list_to_add = &global_symbols;
21495 list_to_add = cu->list_in_scope;
21498 case DW_TAG_inlined_subroutine:
21499 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21501 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21502 SYMBOL_INLINED (sym) = 1;
21503 list_to_add = cu->list_in_scope;
21505 case DW_TAG_template_value_param:
21507 /* Fall through. */
21508 case DW_TAG_constant:
21509 case DW_TAG_variable:
21510 case DW_TAG_member:
21511 /* Compilation with minimal debug info may result in
21512 variables with missing type entries. Change the
21513 misleading `void' type to something sensible. */
21514 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21515 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21517 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21518 /* In the case of DW_TAG_member, we should only be called for
21519 static const members. */
21520 if (die->tag == DW_TAG_member)
21522 /* dwarf2_add_field uses die_is_declaration,
21523 so we do the same. */
21524 gdb_assert (die_is_declaration (die, cu));
21529 dwarf2_const_value (attr, sym, cu);
21530 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21533 if (attr2 && (DW_UNSND (attr2) != 0))
21534 list_to_add = &global_symbols;
21536 list_to_add = cu->list_in_scope;
21540 attr = dwarf2_attr (die, DW_AT_location, cu);
21543 var_decode_location (attr, sym, cu);
21544 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21546 /* Fortran explicitly imports any global symbols to the local
21547 scope by DW_TAG_common_block. */
21548 if (cu->language == language_fortran && die->parent
21549 && die->parent->tag == DW_TAG_common_block)
21552 if (SYMBOL_CLASS (sym) == LOC_STATIC
21553 && SYMBOL_VALUE_ADDRESS (sym) == 0
21554 && !dwarf2_per_objfile->has_section_at_zero)
21556 /* When a static variable is eliminated by the linker,
21557 the corresponding debug information is not stripped
21558 out, but the variable address is set to null;
21559 do not add such variables into symbol table. */
21561 else if (attr2 && (DW_UNSND (attr2) != 0))
21563 /* Workaround gfortran PR debug/40040 - it uses
21564 DW_AT_location for variables in -fPIC libraries which may
21565 get overriden by other libraries/executable and get
21566 a different address. Resolve it by the minimal symbol
21567 which may come from inferior's executable using copy
21568 relocation. Make this workaround only for gfortran as for
21569 other compilers GDB cannot guess the minimal symbol
21570 Fortran mangling kind. */
21571 if (cu->language == language_fortran && die->parent
21572 && die->parent->tag == DW_TAG_module
21574 && startswith (cu->producer, "GNU Fortran"))
21575 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21577 /* A variable with DW_AT_external is never static,
21578 but it may be block-scoped. */
21579 list_to_add = (cu->list_in_scope == &file_symbols
21580 ? &global_symbols : cu->list_in_scope);
21583 list_to_add = cu->list_in_scope;
21587 /* We do not know the address of this symbol.
21588 If it is an external symbol and we have type information
21589 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21590 The address of the variable will then be determined from
21591 the minimal symbol table whenever the variable is
21593 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21595 /* Fortran explicitly imports any global symbols to the local
21596 scope by DW_TAG_common_block. */
21597 if (cu->language == language_fortran && die->parent
21598 && die->parent->tag == DW_TAG_common_block)
21600 /* SYMBOL_CLASS doesn't matter here because
21601 read_common_block is going to reset it. */
21603 list_to_add = cu->list_in_scope;
21605 else if (attr2 && (DW_UNSND (attr2) != 0)
21606 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21608 /* A variable with DW_AT_external is never static, but it
21609 may be block-scoped. */
21610 list_to_add = (cu->list_in_scope == &file_symbols
21611 ? &global_symbols : cu->list_in_scope);
21613 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21615 else if (!die_is_declaration (die, cu))
21617 /* Use the default LOC_OPTIMIZED_OUT class. */
21618 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21620 list_to_add = cu->list_in_scope;
21624 case DW_TAG_formal_parameter:
21625 /* If we are inside a function, mark this as an argument. If
21626 not, we might be looking at an argument to an inlined function
21627 when we do not have enough information to show inlined frames;
21628 pretend it's a local variable in that case so that the user can
21630 if (context_stack_depth > 0
21631 && context_stack[context_stack_depth - 1].name != NULL)
21632 SYMBOL_IS_ARGUMENT (sym) = 1;
21633 attr = dwarf2_attr (die, DW_AT_location, cu);
21636 var_decode_location (attr, sym, cu);
21638 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21641 dwarf2_const_value (attr, sym, cu);
21644 list_to_add = cu->list_in_scope;
21646 case DW_TAG_unspecified_parameters:
21647 /* From varargs functions; gdb doesn't seem to have any
21648 interest in this information, so just ignore it for now.
21651 case DW_TAG_template_type_param:
21653 /* Fall through. */
21654 case DW_TAG_class_type:
21655 case DW_TAG_interface_type:
21656 case DW_TAG_structure_type:
21657 case DW_TAG_union_type:
21658 case DW_TAG_set_type:
21659 case DW_TAG_enumeration_type:
21660 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21661 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21664 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21665 really ever be static objects: otherwise, if you try
21666 to, say, break of a class's method and you're in a file
21667 which doesn't mention that class, it won't work unless
21668 the check for all static symbols in lookup_symbol_aux
21669 saves you. See the OtherFileClass tests in
21670 gdb.c++/namespace.exp. */
21674 list_to_add = (cu->list_in_scope == &file_symbols
21675 && cu->language == language_cplus
21676 ? &global_symbols : cu->list_in_scope);
21678 /* The semantics of C++ state that "struct foo {
21679 ... }" also defines a typedef for "foo". */
21680 if (cu->language == language_cplus
21681 || cu->language == language_ada
21682 || cu->language == language_d
21683 || cu->language == language_rust)
21685 /* The symbol's name is already allocated along
21686 with this objfile, so we don't need to
21687 duplicate it for the type. */
21688 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21689 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21694 case DW_TAG_typedef:
21695 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21696 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21697 list_to_add = cu->list_in_scope;
21699 case DW_TAG_base_type:
21700 case DW_TAG_subrange_type:
21701 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21702 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21703 list_to_add = cu->list_in_scope;
21705 case DW_TAG_enumerator:
21706 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21709 dwarf2_const_value (attr, sym, cu);
21712 /* NOTE: carlton/2003-11-10: See comment above in the
21713 DW_TAG_class_type, etc. block. */
21715 list_to_add = (cu->list_in_scope == &file_symbols
21716 && cu->language == language_cplus
21717 ? &global_symbols : cu->list_in_scope);
21720 case DW_TAG_imported_declaration:
21721 case DW_TAG_namespace:
21722 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21723 list_to_add = &global_symbols;
21725 case DW_TAG_module:
21726 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21727 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21728 list_to_add = &global_symbols;
21730 case DW_TAG_common_block:
21731 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21732 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21733 add_symbol_to_list (sym, cu->list_in_scope);
21736 /* Not a tag we recognize. Hopefully we aren't processing
21737 trash data, but since we must specifically ignore things
21738 we don't recognize, there is nothing else we should do at
21740 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
21741 dwarf_tag_name (die->tag));
21747 sym->hash_next = objfile->template_symbols;
21748 objfile->template_symbols = sym;
21749 list_to_add = NULL;
21752 if (list_to_add != NULL)
21753 add_symbol_to_list (sym, list_to_add);
21755 /* For the benefit of old versions of GCC, check for anonymous
21756 namespaces based on the demangled name. */
21757 if (!cu->processing_has_namespace_info
21758 && cu->language == language_cplus)
21759 cp_scan_for_anonymous_namespaces (sym, objfile);
21764 /* Given an attr with a DW_FORM_dataN value in host byte order,
21765 zero-extend it as appropriate for the symbol's type. The DWARF
21766 standard (v4) is not entirely clear about the meaning of using
21767 DW_FORM_dataN for a constant with a signed type, where the type is
21768 wider than the data. The conclusion of a discussion on the DWARF
21769 list was that this is unspecified. We choose to always zero-extend
21770 because that is the interpretation long in use by GCC. */
21773 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21774 struct dwarf2_cu *cu, LONGEST *value, int bits)
21776 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21777 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21778 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21779 LONGEST l = DW_UNSND (attr);
21781 if (bits < sizeof (*value) * 8)
21783 l &= ((LONGEST) 1 << bits) - 1;
21786 else if (bits == sizeof (*value) * 8)
21790 gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21791 store_unsigned_integer (bytes, bits / 8, byte_order, l);
21798 /* Read a constant value from an attribute. Either set *VALUE, or if
21799 the value does not fit in *VALUE, set *BYTES - either already
21800 allocated on the objfile obstack, or newly allocated on OBSTACK,
21801 or, set *BATON, if we translated the constant to a location
21805 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21806 const char *name, struct obstack *obstack,
21807 struct dwarf2_cu *cu,
21808 LONGEST *value, const gdb_byte **bytes,
21809 struct dwarf2_locexpr_baton **baton)
21811 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21812 struct comp_unit_head *cu_header = &cu->header;
21813 struct dwarf_block *blk;
21814 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21815 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21821 switch (attr->form)
21824 case DW_FORM_GNU_addr_index:
21828 if (TYPE_LENGTH (type) != cu_header->addr_size)
21829 dwarf2_const_value_length_mismatch_complaint (name,
21830 cu_header->addr_size,
21831 TYPE_LENGTH (type));
21832 /* Symbols of this form are reasonably rare, so we just
21833 piggyback on the existing location code rather than writing
21834 a new implementation of symbol_computed_ops. */
21835 *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21836 (*baton)->per_cu = cu->per_cu;
21837 gdb_assert ((*baton)->per_cu);
21839 (*baton)->size = 2 + cu_header->addr_size;
21840 data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21841 (*baton)->data = data;
21843 data[0] = DW_OP_addr;
21844 store_unsigned_integer (&data[1], cu_header->addr_size,
21845 byte_order, DW_ADDR (attr));
21846 data[cu_header->addr_size + 1] = DW_OP_stack_value;
21849 case DW_FORM_string:
21851 case DW_FORM_GNU_str_index:
21852 case DW_FORM_GNU_strp_alt:
21853 /* DW_STRING is already allocated on the objfile obstack, point
21855 *bytes = (const gdb_byte *) DW_STRING (attr);
21857 case DW_FORM_block1:
21858 case DW_FORM_block2:
21859 case DW_FORM_block4:
21860 case DW_FORM_block:
21861 case DW_FORM_exprloc:
21862 case DW_FORM_data16:
21863 blk = DW_BLOCK (attr);
21864 if (TYPE_LENGTH (type) != blk->size)
21865 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21866 TYPE_LENGTH (type));
21867 *bytes = blk->data;
21870 /* The DW_AT_const_value attributes are supposed to carry the
21871 symbol's value "represented as it would be on the target
21872 architecture." By the time we get here, it's already been
21873 converted to host endianness, so we just need to sign- or
21874 zero-extend it as appropriate. */
21875 case DW_FORM_data1:
21876 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21878 case DW_FORM_data2:
21879 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21881 case DW_FORM_data4:
21882 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21884 case DW_FORM_data8:
21885 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21888 case DW_FORM_sdata:
21889 case DW_FORM_implicit_const:
21890 *value = DW_SND (attr);
21893 case DW_FORM_udata:
21894 *value = DW_UNSND (attr);
21898 complaint (&symfile_complaints,
21899 _("unsupported const value attribute form: '%s'"),
21900 dwarf_form_name (attr->form));
21907 /* Copy constant value from an attribute to a symbol. */
21910 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21911 struct dwarf2_cu *cu)
21913 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21915 const gdb_byte *bytes;
21916 struct dwarf2_locexpr_baton *baton;
21918 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21919 SYMBOL_PRINT_NAME (sym),
21920 &objfile->objfile_obstack, cu,
21921 &value, &bytes, &baton);
21925 SYMBOL_LOCATION_BATON (sym) = baton;
21926 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21928 else if (bytes != NULL)
21930 SYMBOL_VALUE_BYTES (sym) = bytes;
21931 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21935 SYMBOL_VALUE (sym) = value;
21936 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21940 /* Return the type of the die in question using its DW_AT_type attribute. */
21942 static struct type *
21943 die_type (struct die_info *die, struct dwarf2_cu *cu)
21945 struct attribute *type_attr;
21947 type_attr = dwarf2_attr (die, DW_AT_type, cu);
21950 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21951 /* A missing DW_AT_type represents a void type. */
21952 return objfile_type (objfile)->builtin_void;
21955 return lookup_die_type (die, type_attr, cu);
21958 /* True iff CU's producer generates GNAT Ada auxiliary information
21959 that allows to find parallel types through that information instead
21960 of having to do expensive parallel lookups by type name. */
21963 need_gnat_info (struct dwarf2_cu *cu)
21965 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
21966 of GNAT produces this auxiliary information, without any indication
21967 that it is produced. Part of enhancing the FSF version of GNAT
21968 to produce that information will be to put in place an indicator
21969 that we can use in order to determine whether the descriptive type
21970 info is available or not. One suggestion that has been made is
21971 to use a new attribute, attached to the CU die. For now, assume
21972 that the descriptive type info is not available. */
21976 /* Return the auxiliary type of the die in question using its
21977 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21978 attribute is not present. */
21980 static struct type *
21981 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21983 struct attribute *type_attr;
21985 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21989 return lookup_die_type (die, type_attr, cu);
21992 /* If DIE has a descriptive_type attribute, then set the TYPE's
21993 descriptive type accordingly. */
21996 set_descriptive_type (struct type *type, struct die_info *die,
21997 struct dwarf2_cu *cu)
21999 struct type *descriptive_type = die_descriptive_type (die, cu);
22001 if (descriptive_type)
22003 ALLOCATE_GNAT_AUX_TYPE (type);
22004 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
22008 /* Return the containing type of the die in question using its
22009 DW_AT_containing_type attribute. */
22011 static struct type *
22012 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
22014 struct attribute *type_attr;
22015 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22017 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
22019 error (_("Dwarf Error: Problem turning containing type into gdb type "
22020 "[in module %s]"), objfile_name (objfile));
22022 return lookup_die_type (die, type_attr, cu);
22025 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22027 static struct type *
22028 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
22030 struct dwarf2_per_objfile *dwarf2_per_objfile
22031 = cu->per_cu->dwarf2_per_objfile;
22032 struct objfile *objfile = dwarf2_per_objfile->objfile;
22033 char *message, *saved;
22035 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
22036 objfile_name (objfile),
22037 to_underlying (cu->header.sect_off),
22038 to_underlying (die->sect_off));
22039 saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22040 message, strlen (message));
22043 return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22046 /* Look up the type of DIE in CU using its type attribute ATTR.
22047 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22048 DW_AT_containing_type.
22049 If there is no type substitute an error marker. */
22051 static struct type *
22052 lookup_die_type (struct die_info *die, const struct attribute *attr,
22053 struct dwarf2_cu *cu)
22055 struct dwarf2_per_objfile *dwarf2_per_objfile
22056 = cu->per_cu->dwarf2_per_objfile;
22057 struct objfile *objfile = dwarf2_per_objfile->objfile;
22058 struct type *this_type;
22060 gdb_assert (attr->name == DW_AT_type
22061 || attr->name == DW_AT_GNAT_descriptive_type
22062 || attr->name == DW_AT_containing_type);
22064 /* First see if we have it cached. */
22066 if (attr->form == DW_FORM_GNU_ref_alt)
22068 struct dwarf2_per_cu_data *per_cu;
22069 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22071 per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22072 dwarf2_per_objfile);
22073 this_type = get_die_type_at_offset (sect_off, per_cu);
22075 else if (attr_form_is_ref (attr))
22077 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22079 this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22081 else if (attr->form == DW_FORM_ref_sig8)
22083 ULONGEST signature = DW_SIGNATURE (attr);
22085 return get_signatured_type (die, signature, cu);
22089 complaint (&symfile_complaints,
22090 _("Dwarf Error: Bad type attribute %s in DIE"
22091 " at 0x%x [in module %s]"),
22092 dwarf_attr_name (attr->name), to_underlying (die->sect_off),
22093 objfile_name (objfile));
22094 return build_error_marker_type (cu, die);
22097 /* If not cached we need to read it in. */
22099 if (this_type == NULL)
22101 struct die_info *type_die = NULL;
22102 struct dwarf2_cu *type_cu = cu;
22104 if (attr_form_is_ref (attr))
22105 type_die = follow_die_ref (die, attr, &type_cu);
22106 if (type_die == NULL)
22107 return build_error_marker_type (cu, die);
22108 /* If we find the type now, it's probably because the type came
22109 from an inter-CU reference and the type's CU got expanded before
22111 this_type = read_type_die (type_die, type_cu);
22114 /* If we still don't have a type use an error marker. */
22116 if (this_type == NULL)
22117 return build_error_marker_type (cu, die);
22122 /* Return the type in DIE, CU.
22123 Returns NULL for invalid types.
22125 This first does a lookup in die_type_hash,
22126 and only reads the die in if necessary.
22128 NOTE: This can be called when reading in partial or full symbols. */
22130 static struct type *
22131 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22133 struct type *this_type;
22135 this_type = get_die_type (die, cu);
22139 return read_type_die_1 (die, cu);
22142 /* Read the type in DIE, CU.
22143 Returns NULL for invalid types. */
22145 static struct type *
22146 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22148 struct type *this_type = NULL;
22152 case DW_TAG_class_type:
22153 case DW_TAG_interface_type:
22154 case DW_TAG_structure_type:
22155 case DW_TAG_union_type:
22156 this_type = read_structure_type (die, cu);
22158 case DW_TAG_enumeration_type:
22159 this_type = read_enumeration_type (die, cu);
22161 case DW_TAG_subprogram:
22162 case DW_TAG_subroutine_type:
22163 case DW_TAG_inlined_subroutine:
22164 this_type = read_subroutine_type (die, cu);
22166 case DW_TAG_array_type:
22167 this_type = read_array_type (die, cu);
22169 case DW_TAG_set_type:
22170 this_type = read_set_type (die, cu);
22172 case DW_TAG_pointer_type:
22173 this_type = read_tag_pointer_type (die, cu);
22175 case DW_TAG_ptr_to_member_type:
22176 this_type = read_tag_ptr_to_member_type (die, cu);
22178 case DW_TAG_reference_type:
22179 this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22181 case DW_TAG_rvalue_reference_type:
22182 this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22184 case DW_TAG_const_type:
22185 this_type = read_tag_const_type (die, cu);
22187 case DW_TAG_volatile_type:
22188 this_type = read_tag_volatile_type (die, cu);
22190 case DW_TAG_restrict_type:
22191 this_type = read_tag_restrict_type (die, cu);
22193 case DW_TAG_string_type:
22194 this_type = read_tag_string_type (die, cu);
22196 case DW_TAG_typedef:
22197 this_type = read_typedef (die, cu);
22199 case DW_TAG_subrange_type:
22200 this_type = read_subrange_type (die, cu);
22202 case DW_TAG_base_type:
22203 this_type = read_base_type (die, cu);
22205 case DW_TAG_unspecified_type:
22206 this_type = read_unspecified_type (die, cu);
22208 case DW_TAG_namespace:
22209 this_type = read_namespace_type (die, cu);
22211 case DW_TAG_module:
22212 this_type = read_module_type (die, cu);
22214 case DW_TAG_atomic_type:
22215 this_type = read_tag_atomic_type (die, cu);
22218 complaint (&symfile_complaints,
22219 _("unexpected tag in read_type_die: '%s'"),
22220 dwarf_tag_name (die->tag));
22227 /* See if we can figure out if the class lives in a namespace. We do
22228 this by looking for a member function; its demangled name will
22229 contain namespace info, if there is any.
22230 Return the computed name or NULL.
22231 Space for the result is allocated on the objfile's obstack.
22232 This is the full-die version of guess_partial_die_structure_name.
22233 In this case we know DIE has no useful parent. */
22236 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22238 struct die_info *spec_die;
22239 struct dwarf2_cu *spec_cu;
22240 struct die_info *child;
22241 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22244 spec_die = die_specification (die, &spec_cu);
22245 if (spec_die != NULL)
22251 for (child = die->child;
22253 child = child->sibling)
22255 if (child->tag == DW_TAG_subprogram)
22257 const char *linkage_name = dw2_linkage_name (child, cu);
22259 if (linkage_name != NULL)
22262 = language_class_name_from_physname (cu->language_defn,
22266 if (actual_name != NULL)
22268 const char *die_name = dwarf2_name (die, cu);
22270 if (die_name != NULL
22271 && strcmp (die_name, actual_name) != 0)
22273 /* Strip off the class name from the full name.
22274 We want the prefix. */
22275 int die_name_len = strlen (die_name);
22276 int actual_name_len = strlen (actual_name);
22278 /* Test for '::' as a sanity check. */
22279 if (actual_name_len > die_name_len + 2
22280 && actual_name[actual_name_len
22281 - die_name_len - 1] == ':')
22282 name = (char *) obstack_copy0 (
22283 &objfile->per_bfd->storage_obstack,
22284 actual_name, actual_name_len - die_name_len - 2);
22287 xfree (actual_name);
22296 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22297 prefix part in such case. See
22298 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22300 static const char *
22301 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22303 struct attribute *attr;
22306 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22307 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22310 if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22313 attr = dw2_linkage_name_attr (die, cu);
22314 if (attr == NULL || DW_STRING (attr) == NULL)
22317 /* dwarf2_name had to be already called. */
22318 gdb_assert (DW_STRING_IS_CANONICAL (attr));
22320 /* Strip the base name, keep any leading namespaces/classes. */
22321 base = strrchr (DW_STRING (attr), ':');
22322 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22325 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22326 return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22328 &base[-1] - DW_STRING (attr));
22331 /* Return the name of the namespace/class that DIE is defined within,
22332 or "" if we can't tell. The caller should not xfree the result.
22334 For example, if we're within the method foo() in the following
22344 then determine_prefix on foo's die will return "N::C". */
22346 static const char *
22347 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22349 struct dwarf2_per_objfile *dwarf2_per_objfile
22350 = cu->per_cu->dwarf2_per_objfile;
22351 struct die_info *parent, *spec_die;
22352 struct dwarf2_cu *spec_cu;
22353 struct type *parent_type;
22354 const char *retval;
22356 if (cu->language != language_cplus
22357 && cu->language != language_fortran && cu->language != language_d
22358 && cu->language != language_rust)
22361 retval = anonymous_struct_prefix (die, cu);
22365 /* We have to be careful in the presence of DW_AT_specification.
22366 For example, with GCC 3.4, given the code
22370 // Definition of N::foo.
22374 then we'll have a tree of DIEs like this:
22376 1: DW_TAG_compile_unit
22377 2: DW_TAG_namespace // N
22378 3: DW_TAG_subprogram // declaration of N::foo
22379 4: DW_TAG_subprogram // definition of N::foo
22380 DW_AT_specification // refers to die #3
22382 Thus, when processing die #4, we have to pretend that we're in
22383 the context of its DW_AT_specification, namely the contex of die
22386 spec_die = die_specification (die, &spec_cu);
22387 if (spec_die == NULL)
22388 parent = die->parent;
22391 parent = spec_die->parent;
22395 if (parent == NULL)
22397 else if (parent->building_fullname)
22400 const char *parent_name;
22402 /* It has been seen on RealView 2.2 built binaries,
22403 DW_TAG_template_type_param types actually _defined_ as
22404 children of the parent class:
22407 template class <class Enum> Class{};
22408 Class<enum E> class_e;
22410 1: DW_TAG_class_type (Class)
22411 2: DW_TAG_enumeration_type (E)
22412 3: DW_TAG_enumerator (enum1:0)
22413 3: DW_TAG_enumerator (enum2:1)
22415 2: DW_TAG_template_type_param
22416 DW_AT_type DW_FORM_ref_udata (E)
22418 Besides being broken debug info, it can put GDB into an
22419 infinite loop. Consider:
22421 When we're building the full name for Class<E>, we'll start
22422 at Class, and go look over its template type parameters,
22423 finding E. We'll then try to build the full name of E, and
22424 reach here. We're now trying to build the full name of E,
22425 and look over the parent DIE for containing scope. In the
22426 broken case, if we followed the parent DIE of E, we'd again
22427 find Class, and once again go look at its template type
22428 arguments, etc., etc. Simply don't consider such parent die
22429 as source-level parent of this die (it can't be, the language
22430 doesn't allow it), and break the loop here. */
22431 name = dwarf2_name (die, cu);
22432 parent_name = dwarf2_name (parent, cu);
22433 complaint (&symfile_complaints,
22434 _("template param type '%s' defined within parent '%s'"),
22435 name ? name : "<unknown>",
22436 parent_name ? parent_name : "<unknown>");
22440 switch (parent->tag)
22442 case DW_TAG_namespace:
22443 parent_type = read_type_die (parent, cu);
22444 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22445 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22446 Work around this problem here. */
22447 if (cu->language == language_cplus
22448 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
22450 /* We give a name to even anonymous namespaces. */
22451 return TYPE_TAG_NAME (parent_type);
22452 case DW_TAG_class_type:
22453 case DW_TAG_interface_type:
22454 case DW_TAG_structure_type:
22455 case DW_TAG_union_type:
22456 case DW_TAG_module:
22457 parent_type = read_type_die (parent, cu);
22458 if (TYPE_TAG_NAME (parent_type) != NULL)
22459 return TYPE_TAG_NAME (parent_type);
22461 /* An anonymous structure is only allowed non-static data
22462 members; no typedefs, no member functions, et cetera.
22463 So it does not need a prefix. */
22465 case DW_TAG_compile_unit:
22466 case DW_TAG_partial_unit:
22467 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22468 if (cu->language == language_cplus
22469 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22470 && die->child != NULL
22471 && (die->tag == DW_TAG_class_type
22472 || die->tag == DW_TAG_structure_type
22473 || die->tag == DW_TAG_union_type))
22475 char *name = guess_full_die_structure_name (die, cu);
22480 case DW_TAG_enumeration_type:
22481 parent_type = read_type_die (parent, cu);
22482 if (TYPE_DECLARED_CLASS (parent_type))
22484 if (TYPE_TAG_NAME (parent_type) != NULL)
22485 return TYPE_TAG_NAME (parent_type);
22488 /* Fall through. */
22490 return determine_prefix (parent, cu);
22494 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22495 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22496 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22497 an obconcat, otherwise allocate storage for the result. The CU argument is
22498 used to determine the language and hence, the appropriate separator. */
22500 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22503 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22504 int physname, struct dwarf2_cu *cu)
22506 const char *lead = "";
22509 if (suffix == NULL || suffix[0] == '\0'
22510 || prefix == NULL || prefix[0] == '\0')
22512 else if (cu->language == language_d)
22514 /* For D, the 'main' function could be defined in any module, but it
22515 should never be prefixed. */
22516 if (strcmp (suffix, "D main") == 0)
22524 else if (cu->language == language_fortran && physname)
22526 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22527 DW_AT_MIPS_linkage_name is preferred and used instead. */
22535 if (prefix == NULL)
22537 if (suffix == NULL)
22544 xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22546 strcpy (retval, lead);
22547 strcat (retval, prefix);
22548 strcat (retval, sep);
22549 strcat (retval, suffix);
22554 /* We have an obstack. */
22555 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22559 /* Return sibling of die, NULL if no sibling. */
22561 static struct die_info *
22562 sibling_die (struct die_info *die)
22564 return die->sibling;
22567 /* Get name of a die, return NULL if not found. */
22569 static const char *
22570 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22571 struct obstack *obstack)
22573 if (name && cu->language == language_cplus)
22575 std::string canon_name = cp_canonicalize_string (name);
22577 if (!canon_name.empty ())
22579 if (canon_name != name)
22580 name = (const char *) obstack_copy0 (obstack,
22581 canon_name.c_str (),
22582 canon_name.length ());
22589 /* Get name of a die, return NULL if not found.
22590 Anonymous namespaces are converted to their magic string. */
22592 static const char *
22593 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22595 struct attribute *attr;
22596 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22598 attr = dwarf2_attr (die, DW_AT_name, cu);
22599 if ((!attr || !DW_STRING (attr))
22600 && die->tag != DW_TAG_namespace
22601 && die->tag != DW_TAG_class_type
22602 && die->tag != DW_TAG_interface_type
22603 && die->tag != DW_TAG_structure_type
22604 && die->tag != DW_TAG_union_type)
22609 case DW_TAG_compile_unit:
22610 case DW_TAG_partial_unit:
22611 /* Compilation units have a DW_AT_name that is a filename, not
22612 a source language identifier. */
22613 case DW_TAG_enumeration_type:
22614 case DW_TAG_enumerator:
22615 /* These tags always have simple identifiers already; no need
22616 to canonicalize them. */
22617 return DW_STRING (attr);
22619 case DW_TAG_namespace:
22620 if (attr != NULL && DW_STRING (attr) != NULL)
22621 return DW_STRING (attr);
22622 return CP_ANONYMOUS_NAMESPACE_STR;
22624 case DW_TAG_class_type:
22625 case DW_TAG_interface_type:
22626 case DW_TAG_structure_type:
22627 case DW_TAG_union_type:
22628 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22629 structures or unions. These were of the form "._%d" in GCC 4.1,
22630 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22631 and GCC 4.4. We work around this problem by ignoring these. */
22632 if (attr && DW_STRING (attr)
22633 && (startswith (DW_STRING (attr), "._")
22634 || startswith (DW_STRING (attr), "<anonymous")))
22637 /* GCC might emit a nameless typedef that has a linkage name. See
22638 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22639 if (!attr || DW_STRING (attr) == NULL)
22641 char *demangled = NULL;
22643 attr = dw2_linkage_name_attr (die, cu);
22644 if (attr == NULL || DW_STRING (attr) == NULL)
22647 /* Avoid demangling DW_STRING (attr) the second time on a second
22648 call for the same DIE. */
22649 if (!DW_STRING_IS_CANONICAL (attr))
22650 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22656 /* FIXME: we already did this for the partial symbol... */
22659 obstack_copy0 (&objfile->per_bfd->storage_obstack,
22660 demangled, strlen (demangled)));
22661 DW_STRING_IS_CANONICAL (attr) = 1;
22664 /* Strip any leading namespaces/classes, keep only the base name.
22665 DW_AT_name for named DIEs does not contain the prefixes. */
22666 base = strrchr (DW_STRING (attr), ':');
22667 if (base && base > DW_STRING (attr) && base[-1] == ':')
22670 return DW_STRING (attr);
22679 if (!DW_STRING_IS_CANONICAL (attr))
22682 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22683 &objfile->per_bfd->storage_obstack);
22684 DW_STRING_IS_CANONICAL (attr) = 1;
22686 return DW_STRING (attr);
22689 /* Return the die that this die in an extension of, or NULL if there
22690 is none. *EXT_CU is the CU containing DIE on input, and the CU
22691 containing the return value on output. */
22693 static struct die_info *
22694 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22696 struct attribute *attr;
22698 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22702 return follow_die_ref (die, attr, ext_cu);
22705 /* Convert a DIE tag into its string name. */
22707 static const char *
22708 dwarf_tag_name (unsigned tag)
22710 const char *name = get_DW_TAG_name (tag);
22713 return "DW_TAG_<unknown>";
22718 /* Convert a DWARF attribute code into its string name. */
22720 static const char *
22721 dwarf_attr_name (unsigned attr)
22725 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22726 if (attr == DW_AT_MIPS_fde)
22727 return "DW_AT_MIPS_fde";
22729 if (attr == DW_AT_HP_block_index)
22730 return "DW_AT_HP_block_index";
22733 name = get_DW_AT_name (attr);
22736 return "DW_AT_<unknown>";
22741 /* Convert a DWARF value form code into its string name. */
22743 static const char *
22744 dwarf_form_name (unsigned form)
22746 const char *name = get_DW_FORM_name (form);
22749 return "DW_FORM_<unknown>";
22754 static const char *
22755 dwarf_bool_name (unsigned mybool)
22763 /* Convert a DWARF type code into its string name. */
22765 static const char *
22766 dwarf_type_encoding_name (unsigned enc)
22768 const char *name = get_DW_ATE_name (enc);
22771 return "DW_ATE_<unknown>";
22777 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22781 print_spaces (indent, f);
22782 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
22783 dwarf_tag_name (die->tag), die->abbrev,
22784 to_underlying (die->sect_off));
22786 if (die->parent != NULL)
22788 print_spaces (indent, f);
22789 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
22790 to_underlying (die->parent->sect_off));
22793 print_spaces (indent, f);
22794 fprintf_unfiltered (f, " has children: %s\n",
22795 dwarf_bool_name (die->child != NULL));
22797 print_spaces (indent, f);
22798 fprintf_unfiltered (f, " attributes:\n");
22800 for (i = 0; i < die->num_attrs; ++i)
22802 print_spaces (indent, f);
22803 fprintf_unfiltered (f, " %s (%s) ",
22804 dwarf_attr_name (die->attrs[i].name),
22805 dwarf_form_name (die->attrs[i].form));
22807 switch (die->attrs[i].form)
22810 case DW_FORM_GNU_addr_index:
22811 fprintf_unfiltered (f, "address: ");
22812 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22814 case DW_FORM_block2:
22815 case DW_FORM_block4:
22816 case DW_FORM_block:
22817 case DW_FORM_block1:
22818 fprintf_unfiltered (f, "block: size %s",
22819 pulongest (DW_BLOCK (&die->attrs[i])->size));
22821 case DW_FORM_exprloc:
22822 fprintf_unfiltered (f, "expression: size %s",
22823 pulongest (DW_BLOCK (&die->attrs[i])->size));
22825 case DW_FORM_data16:
22826 fprintf_unfiltered (f, "constant of 16 bytes");
22828 case DW_FORM_ref_addr:
22829 fprintf_unfiltered (f, "ref address: ");
22830 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22832 case DW_FORM_GNU_ref_alt:
22833 fprintf_unfiltered (f, "alt ref address: ");
22834 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22840 case DW_FORM_ref_udata:
22841 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22842 (long) (DW_UNSND (&die->attrs[i])));
22844 case DW_FORM_data1:
22845 case DW_FORM_data2:
22846 case DW_FORM_data4:
22847 case DW_FORM_data8:
22848 case DW_FORM_udata:
22849 case DW_FORM_sdata:
22850 fprintf_unfiltered (f, "constant: %s",
22851 pulongest (DW_UNSND (&die->attrs[i])));
22853 case DW_FORM_sec_offset:
22854 fprintf_unfiltered (f, "section offset: %s",
22855 pulongest (DW_UNSND (&die->attrs[i])));
22857 case DW_FORM_ref_sig8:
22858 fprintf_unfiltered (f, "signature: %s",
22859 hex_string (DW_SIGNATURE (&die->attrs[i])));
22861 case DW_FORM_string:
22863 case DW_FORM_line_strp:
22864 case DW_FORM_GNU_str_index:
22865 case DW_FORM_GNU_strp_alt:
22866 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22867 DW_STRING (&die->attrs[i])
22868 ? DW_STRING (&die->attrs[i]) : "",
22869 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22872 if (DW_UNSND (&die->attrs[i]))
22873 fprintf_unfiltered (f, "flag: TRUE");
22875 fprintf_unfiltered (f, "flag: FALSE");
22877 case DW_FORM_flag_present:
22878 fprintf_unfiltered (f, "flag: TRUE");
22880 case DW_FORM_indirect:
22881 /* The reader will have reduced the indirect form to
22882 the "base form" so this form should not occur. */
22883 fprintf_unfiltered (f,
22884 "unexpected attribute form: DW_FORM_indirect");
22886 case DW_FORM_implicit_const:
22887 fprintf_unfiltered (f, "constant: %s",
22888 plongest (DW_SND (&die->attrs[i])));
22891 fprintf_unfiltered (f, "unsupported attribute form: %d.",
22892 die->attrs[i].form);
22895 fprintf_unfiltered (f, "\n");
22900 dump_die_for_error (struct die_info *die)
22902 dump_die_shallow (gdb_stderr, 0, die);
22906 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22908 int indent = level * 4;
22910 gdb_assert (die != NULL);
22912 if (level >= max_level)
22915 dump_die_shallow (f, indent, die);
22917 if (die->child != NULL)
22919 print_spaces (indent, f);
22920 fprintf_unfiltered (f, " Children:");
22921 if (level + 1 < max_level)
22923 fprintf_unfiltered (f, "\n");
22924 dump_die_1 (f, level + 1, max_level, die->child);
22928 fprintf_unfiltered (f,
22929 " [not printed, max nesting level reached]\n");
22933 if (die->sibling != NULL && level > 0)
22935 dump_die_1 (f, level, max_level, die->sibling);
22939 /* This is called from the pdie macro in gdbinit.in.
22940 It's not static so gcc will keep a copy callable from gdb. */
22943 dump_die (struct die_info *die, int max_level)
22945 dump_die_1 (gdb_stdlog, 0, max_level, die);
22949 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22953 slot = htab_find_slot_with_hash (cu->die_hash, die,
22954 to_underlying (die->sect_off),
22960 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22964 dwarf2_get_ref_die_offset (const struct attribute *attr)
22966 if (attr_form_is_ref (attr))
22967 return (sect_offset) DW_UNSND (attr);
22969 complaint (&symfile_complaints,
22970 _("unsupported die ref attribute form: '%s'"),
22971 dwarf_form_name (attr->form));
22975 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22976 * the value held by the attribute is not constant. */
22979 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22981 if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22982 return DW_SND (attr);
22983 else if (attr->form == DW_FORM_udata
22984 || attr->form == DW_FORM_data1
22985 || attr->form == DW_FORM_data2
22986 || attr->form == DW_FORM_data4
22987 || attr->form == DW_FORM_data8)
22988 return DW_UNSND (attr);
22991 /* For DW_FORM_data16 see attr_form_is_constant. */
22992 complaint (&symfile_complaints,
22993 _("Attribute value is not a constant (%s)"),
22994 dwarf_form_name (attr->form));
22995 return default_value;
22999 /* Follow reference or signature attribute ATTR of SRC_DIE.
23000 On entry *REF_CU is the CU of SRC_DIE.
23001 On exit *REF_CU is the CU of the result. */
23003 static struct die_info *
23004 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
23005 struct dwarf2_cu **ref_cu)
23007 struct die_info *die;
23009 if (attr_form_is_ref (attr))
23010 die = follow_die_ref (src_die, attr, ref_cu);
23011 else if (attr->form == DW_FORM_ref_sig8)
23012 die = follow_die_sig (src_die, attr, ref_cu);
23015 dump_die_for_error (src_die);
23016 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23017 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23023 /* Follow reference OFFSET.
23024 On entry *REF_CU is the CU of the source die referencing OFFSET.
23025 On exit *REF_CU is the CU of the result.
23026 Returns NULL if OFFSET is invalid. */
23028 static struct die_info *
23029 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
23030 struct dwarf2_cu **ref_cu)
23032 struct die_info temp_die;
23033 struct dwarf2_cu *target_cu, *cu = *ref_cu;
23034 struct dwarf2_per_objfile *dwarf2_per_objfile
23035 = cu->per_cu->dwarf2_per_objfile;
23036 struct objfile *objfile = dwarf2_per_objfile->objfile;
23038 gdb_assert (cu->per_cu != NULL);
23042 if (cu->per_cu->is_debug_types)
23044 /* .debug_types CUs cannot reference anything outside their CU.
23045 If they need to, they have to reference a signatured type via
23046 DW_FORM_ref_sig8. */
23047 if (!offset_in_cu_p (&cu->header, sect_off))
23050 else if (offset_in_dwz != cu->per_cu->is_dwz
23051 || !offset_in_cu_p (&cu->header, sect_off))
23053 struct dwarf2_per_cu_data *per_cu;
23055 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23056 dwarf2_per_objfile);
23058 /* If necessary, add it to the queue and load its DIEs. */
23059 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23060 load_full_comp_unit (per_cu, cu->language);
23062 target_cu = per_cu->cu;
23064 else if (cu->dies == NULL)
23066 /* We're loading full DIEs during partial symbol reading. */
23067 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23068 load_full_comp_unit (cu->per_cu, language_minimal);
23071 *ref_cu = target_cu;
23072 temp_die.sect_off = sect_off;
23073 return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23075 to_underlying (sect_off));
23078 /* Follow reference attribute ATTR of SRC_DIE.
23079 On entry *REF_CU is the CU of SRC_DIE.
23080 On exit *REF_CU is the CU of the result. */
23082 static struct die_info *
23083 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23084 struct dwarf2_cu **ref_cu)
23086 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23087 struct dwarf2_cu *cu = *ref_cu;
23088 struct die_info *die;
23090 die = follow_die_offset (sect_off,
23091 (attr->form == DW_FORM_GNU_ref_alt
23092 || cu->per_cu->is_dwz),
23095 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
23096 "at 0x%x [in module %s]"),
23097 to_underlying (sect_off), to_underlying (src_die->sect_off),
23098 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23103 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23104 Returned value is intended for DW_OP_call*. Returned
23105 dwarf2_locexpr_baton->data has lifetime of
23106 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23108 struct dwarf2_locexpr_baton
23109 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23110 struct dwarf2_per_cu_data *per_cu,
23111 CORE_ADDR (*get_frame_pc) (void *baton),
23114 struct dwarf2_cu *cu;
23115 struct die_info *die;
23116 struct attribute *attr;
23117 struct dwarf2_locexpr_baton retval;
23118 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23119 struct dwarf2_per_objfile *dwarf2_per_objfile
23120 = get_dwarf2_per_objfile (objfile);
23122 if (per_cu->cu == NULL)
23127 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23128 Instead just throw an error, not much else we can do. */
23129 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
23130 to_underlying (sect_off), objfile_name (objfile));
23133 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23135 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
23136 to_underlying (sect_off), objfile_name (objfile));
23138 attr = dwarf2_attr (die, DW_AT_location, cu);
23141 /* DWARF: "If there is no such attribute, then there is no effect.".
23142 DATA is ignored if SIZE is 0. */
23144 retval.data = NULL;
23147 else if (attr_form_is_section_offset (attr))
23149 struct dwarf2_loclist_baton loclist_baton;
23150 CORE_ADDR pc = (*get_frame_pc) (baton);
23153 fill_in_loclist_baton (cu, &loclist_baton, attr);
23155 retval.data = dwarf2_find_location_expression (&loclist_baton,
23157 retval.size = size;
23161 if (!attr_form_is_block (attr))
23162 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
23163 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23164 to_underlying (sect_off), objfile_name (objfile));
23166 retval.data = DW_BLOCK (attr)->data;
23167 retval.size = DW_BLOCK (attr)->size;
23169 retval.per_cu = cu->per_cu;
23171 age_cached_comp_units (dwarf2_per_objfile);
23176 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23179 struct dwarf2_locexpr_baton
23180 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23181 struct dwarf2_per_cu_data *per_cu,
23182 CORE_ADDR (*get_frame_pc) (void *baton),
23185 sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23187 return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23190 /* Write a constant of a given type as target-ordered bytes into
23193 static const gdb_byte *
23194 write_constant_as_bytes (struct obstack *obstack,
23195 enum bfd_endian byte_order,
23202 *len = TYPE_LENGTH (type);
23203 result = (gdb_byte *) obstack_alloc (obstack, *len);
23204 store_unsigned_integer (result, *len, byte_order, value);
23209 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23210 pointer to the constant bytes and set LEN to the length of the
23211 data. If memory is needed, allocate it on OBSTACK. If the DIE
23212 does not have a DW_AT_const_value, return NULL. */
23215 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23216 struct dwarf2_per_cu_data *per_cu,
23217 struct obstack *obstack,
23220 struct dwarf2_cu *cu;
23221 struct die_info *die;
23222 struct attribute *attr;
23223 const gdb_byte *result = NULL;
23226 enum bfd_endian byte_order;
23227 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23229 if (per_cu->cu == NULL)
23234 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23235 Instead just throw an error, not much else we can do. */
23236 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
23237 to_underlying (sect_off), objfile_name (objfile));
23240 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23242 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
23243 to_underlying (sect_off), objfile_name (objfile));
23246 attr = dwarf2_attr (die, DW_AT_const_value, cu);
23250 byte_order = (bfd_big_endian (objfile->obfd)
23251 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23253 switch (attr->form)
23256 case DW_FORM_GNU_addr_index:
23260 *len = cu->header.addr_size;
23261 tem = (gdb_byte *) obstack_alloc (obstack, *len);
23262 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23266 case DW_FORM_string:
23268 case DW_FORM_GNU_str_index:
23269 case DW_FORM_GNU_strp_alt:
23270 /* DW_STRING is already allocated on the objfile obstack, point
23272 result = (const gdb_byte *) DW_STRING (attr);
23273 *len = strlen (DW_STRING (attr));
23275 case DW_FORM_block1:
23276 case DW_FORM_block2:
23277 case DW_FORM_block4:
23278 case DW_FORM_block:
23279 case DW_FORM_exprloc:
23280 case DW_FORM_data16:
23281 result = DW_BLOCK (attr)->data;
23282 *len = DW_BLOCK (attr)->size;
23285 /* The DW_AT_const_value attributes are supposed to carry the
23286 symbol's value "represented as it would be on the target
23287 architecture." By the time we get here, it's already been
23288 converted to host endianness, so we just need to sign- or
23289 zero-extend it as appropriate. */
23290 case DW_FORM_data1:
23291 type = die_type (die, cu);
23292 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23293 if (result == NULL)
23294 result = write_constant_as_bytes (obstack, byte_order,
23297 case DW_FORM_data2:
23298 type = die_type (die, cu);
23299 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23300 if (result == NULL)
23301 result = write_constant_as_bytes (obstack, byte_order,
23304 case DW_FORM_data4:
23305 type = die_type (die, cu);
23306 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23307 if (result == NULL)
23308 result = write_constant_as_bytes (obstack, byte_order,
23311 case DW_FORM_data8:
23312 type = die_type (die, cu);
23313 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23314 if (result == NULL)
23315 result = write_constant_as_bytes (obstack, byte_order,
23319 case DW_FORM_sdata:
23320 case DW_FORM_implicit_const:
23321 type = die_type (die, cu);
23322 result = write_constant_as_bytes (obstack, byte_order,
23323 type, DW_SND (attr), len);
23326 case DW_FORM_udata:
23327 type = die_type (die, cu);
23328 result = write_constant_as_bytes (obstack, byte_order,
23329 type, DW_UNSND (attr), len);
23333 complaint (&symfile_complaints,
23334 _("unsupported const value attribute form: '%s'"),
23335 dwarf_form_name (attr->form));
23342 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23343 valid type for this die is found. */
23346 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23347 struct dwarf2_per_cu_data *per_cu)
23349 struct dwarf2_cu *cu;
23350 struct die_info *die;
23352 if (per_cu->cu == NULL)
23358 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23362 return die_type (die, cu);
23365 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23369 dwarf2_get_die_type (cu_offset die_offset,
23370 struct dwarf2_per_cu_data *per_cu)
23372 sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23373 return get_die_type_at_offset (die_offset_sect, per_cu);
23376 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23377 On entry *REF_CU is the CU of SRC_DIE.
23378 On exit *REF_CU is the CU of the result.
23379 Returns NULL if the referenced DIE isn't found. */
23381 static struct die_info *
23382 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23383 struct dwarf2_cu **ref_cu)
23385 struct die_info temp_die;
23386 struct dwarf2_cu *sig_cu;
23387 struct die_info *die;
23389 /* While it might be nice to assert sig_type->type == NULL here,
23390 we can get here for DW_AT_imported_declaration where we need
23391 the DIE not the type. */
23393 /* If necessary, add it to the queue and load its DIEs. */
23395 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23396 read_signatured_type (sig_type);
23398 sig_cu = sig_type->per_cu.cu;
23399 gdb_assert (sig_cu != NULL);
23400 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23401 temp_die.sect_off = sig_type->type_offset_in_section;
23402 die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23403 to_underlying (temp_die.sect_off));
23406 struct dwarf2_per_objfile *dwarf2_per_objfile
23407 = (*ref_cu)->per_cu->dwarf2_per_objfile;
23409 /* For .gdb_index version 7 keep track of included TUs.
23410 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23411 if (dwarf2_per_objfile->index_table != NULL
23412 && dwarf2_per_objfile->index_table->version <= 7)
23414 VEC_safe_push (dwarf2_per_cu_ptr,
23415 (*ref_cu)->per_cu->imported_symtabs,
23426 /* Follow signatured type referenced by ATTR in SRC_DIE.
23427 On entry *REF_CU is the CU of SRC_DIE.
23428 On exit *REF_CU is the CU of the result.
23429 The result is the DIE of the type.
23430 If the referenced type cannot be found an error is thrown. */
23432 static struct die_info *
23433 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23434 struct dwarf2_cu **ref_cu)
23436 ULONGEST signature = DW_SIGNATURE (attr);
23437 struct signatured_type *sig_type;
23438 struct die_info *die;
23440 gdb_assert (attr->form == DW_FORM_ref_sig8);
23442 sig_type = lookup_signatured_type (*ref_cu, signature);
23443 /* sig_type will be NULL if the signatured type is missing from
23445 if (sig_type == NULL)
23447 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23448 " from DIE at 0x%x [in module %s]"),
23449 hex_string (signature), to_underlying (src_die->sect_off),
23450 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23453 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23456 dump_die_for_error (src_die);
23457 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23458 " from DIE at 0x%x [in module %s]"),
23459 hex_string (signature), to_underlying (src_die->sect_off),
23460 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23466 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23467 reading in and processing the type unit if necessary. */
23469 static struct type *
23470 get_signatured_type (struct die_info *die, ULONGEST signature,
23471 struct dwarf2_cu *cu)
23473 struct dwarf2_per_objfile *dwarf2_per_objfile
23474 = cu->per_cu->dwarf2_per_objfile;
23475 struct signatured_type *sig_type;
23476 struct dwarf2_cu *type_cu;
23477 struct die_info *type_die;
23480 sig_type = lookup_signatured_type (cu, signature);
23481 /* sig_type will be NULL if the signatured type is missing from
23483 if (sig_type == NULL)
23485 complaint (&symfile_complaints,
23486 _("Dwarf Error: Cannot find signatured DIE %s referenced"
23487 " from DIE at 0x%x [in module %s]"),
23488 hex_string (signature), to_underlying (die->sect_off),
23489 objfile_name (dwarf2_per_objfile->objfile));
23490 return build_error_marker_type (cu, die);
23493 /* If we already know the type we're done. */
23494 if (sig_type->type != NULL)
23495 return sig_type->type;
23498 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23499 if (type_die != NULL)
23501 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23502 is created. This is important, for example, because for c++ classes
23503 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23504 type = read_type_die (type_die, type_cu);
23507 complaint (&symfile_complaints,
23508 _("Dwarf Error: Cannot build signatured type %s"
23509 " referenced from DIE at 0x%x [in module %s]"),
23510 hex_string (signature), to_underlying (die->sect_off),
23511 objfile_name (dwarf2_per_objfile->objfile));
23512 type = build_error_marker_type (cu, die);
23517 complaint (&symfile_complaints,
23518 _("Dwarf Error: Problem reading signatured DIE %s referenced"
23519 " from DIE at 0x%x [in module %s]"),
23520 hex_string (signature), to_underlying (die->sect_off),
23521 objfile_name (dwarf2_per_objfile->objfile));
23522 type = build_error_marker_type (cu, die);
23524 sig_type->type = type;
23529 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23530 reading in and processing the type unit if necessary. */
23532 static struct type *
23533 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23534 struct dwarf2_cu *cu) /* ARI: editCase function */
23536 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23537 if (attr_form_is_ref (attr))
23539 struct dwarf2_cu *type_cu = cu;
23540 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23542 return read_type_die (type_die, type_cu);
23544 else if (attr->form == DW_FORM_ref_sig8)
23546 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23550 struct dwarf2_per_objfile *dwarf2_per_objfile
23551 = cu->per_cu->dwarf2_per_objfile;
23553 complaint (&symfile_complaints,
23554 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23555 " at 0x%x [in module %s]"),
23556 dwarf_form_name (attr->form), to_underlying (die->sect_off),
23557 objfile_name (dwarf2_per_objfile->objfile));
23558 return build_error_marker_type (cu, die);
23562 /* Load the DIEs associated with type unit PER_CU into memory. */
23565 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23567 struct signatured_type *sig_type;
23569 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23570 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23572 /* We have the per_cu, but we need the signatured_type.
23573 Fortunately this is an easy translation. */
23574 gdb_assert (per_cu->is_debug_types);
23575 sig_type = (struct signatured_type *) per_cu;
23577 gdb_assert (per_cu->cu == NULL);
23579 read_signatured_type (sig_type);
23581 gdb_assert (per_cu->cu != NULL);
23584 /* die_reader_func for read_signatured_type.
23585 This is identical to load_full_comp_unit_reader,
23586 but is kept separate for now. */
23589 read_signatured_type_reader (const struct die_reader_specs *reader,
23590 const gdb_byte *info_ptr,
23591 struct die_info *comp_unit_die,
23595 struct dwarf2_cu *cu = reader->cu;
23597 gdb_assert (cu->die_hash == NULL);
23599 htab_create_alloc_ex (cu->header.length / 12,
23603 &cu->comp_unit_obstack,
23604 hashtab_obstack_allocate,
23605 dummy_obstack_deallocate);
23608 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23609 &info_ptr, comp_unit_die);
23610 cu->dies = comp_unit_die;
23611 /* comp_unit_die is not stored in die_hash, no need. */
23613 /* We try not to read any attributes in this function, because not
23614 all CUs needed for references have been loaded yet, and symbol
23615 table processing isn't initialized. But we have to set the CU language,
23616 or we won't be able to build types correctly.
23617 Similarly, if we do not read the producer, we can not apply
23618 producer-specific interpretation. */
23619 prepare_one_comp_unit (cu, cu->dies, language_minimal);
23622 /* Read in a signatured type and build its CU and DIEs.
23623 If the type is a stub for the real type in a DWO file,
23624 read in the real type from the DWO file as well. */
23627 read_signatured_type (struct signatured_type *sig_type)
23629 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23631 gdb_assert (per_cu->is_debug_types);
23632 gdb_assert (per_cu->cu == NULL);
23634 init_cutu_and_read_dies (per_cu, NULL, 0, 1,
23635 read_signatured_type_reader, NULL);
23636 sig_type->per_cu.tu_read = 1;
23639 /* Decode simple location descriptions.
23640 Given a pointer to a dwarf block that defines a location, compute
23641 the location and return the value.
23643 NOTE drow/2003-11-18: This function is called in two situations
23644 now: for the address of static or global variables (partial symbols
23645 only) and for offsets into structures which are expected to be
23646 (more or less) constant. The partial symbol case should go away,
23647 and only the constant case should remain. That will let this
23648 function complain more accurately. A few special modes are allowed
23649 without complaint for global variables (for instance, global
23650 register values and thread-local values).
23652 A location description containing no operations indicates that the
23653 object is optimized out. The return value is 0 for that case.
23654 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23655 callers will only want a very basic result and this can become a
23658 Note that stack[0] is unused except as a default error return. */
23661 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23663 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23665 size_t size = blk->size;
23666 const gdb_byte *data = blk->data;
23667 CORE_ADDR stack[64];
23669 unsigned int bytes_read, unsnd;
23675 stack[++stacki] = 0;
23714 stack[++stacki] = op - DW_OP_lit0;
23749 stack[++stacki] = op - DW_OP_reg0;
23751 dwarf2_complex_location_expr_complaint ();
23755 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23757 stack[++stacki] = unsnd;
23759 dwarf2_complex_location_expr_complaint ();
23763 stack[++stacki] = read_address (objfile->obfd, &data[i],
23768 case DW_OP_const1u:
23769 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23773 case DW_OP_const1s:
23774 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23778 case DW_OP_const2u:
23779 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23783 case DW_OP_const2s:
23784 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23788 case DW_OP_const4u:
23789 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23793 case DW_OP_const4s:
23794 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23798 case DW_OP_const8u:
23799 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23804 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23810 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23815 stack[stacki + 1] = stack[stacki];
23820 stack[stacki - 1] += stack[stacki];
23824 case DW_OP_plus_uconst:
23825 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23831 stack[stacki - 1] -= stack[stacki];
23836 /* If we're not the last op, then we definitely can't encode
23837 this using GDB's address_class enum. This is valid for partial
23838 global symbols, although the variable's address will be bogus
23841 dwarf2_complex_location_expr_complaint ();
23844 case DW_OP_GNU_push_tls_address:
23845 case DW_OP_form_tls_address:
23846 /* The top of the stack has the offset from the beginning
23847 of the thread control block at which the variable is located. */
23848 /* Nothing should follow this operator, so the top of stack would
23850 /* This is valid for partial global symbols, but the variable's
23851 address will be bogus in the psymtab. Make it always at least
23852 non-zero to not look as a variable garbage collected by linker
23853 which have DW_OP_addr 0. */
23855 dwarf2_complex_location_expr_complaint ();
23859 case DW_OP_GNU_uninit:
23862 case DW_OP_GNU_addr_index:
23863 case DW_OP_GNU_const_index:
23864 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23871 const char *name = get_DW_OP_name (op);
23874 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
23877 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
23881 return (stack[stacki]);
23884 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23885 outside of the allocated space. Also enforce minimum>0. */
23886 if (stacki >= ARRAY_SIZE (stack) - 1)
23888 complaint (&symfile_complaints,
23889 _("location description stack overflow"));
23895 complaint (&symfile_complaints,
23896 _("location description stack underflow"));
23900 return (stack[stacki]);
23903 /* memory allocation interface */
23905 static struct dwarf_block *
23906 dwarf_alloc_block (struct dwarf2_cu *cu)
23908 return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23911 static struct die_info *
23912 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23914 struct die_info *die;
23915 size_t size = sizeof (struct die_info);
23918 size += (num_attrs - 1) * sizeof (struct attribute);
23920 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23921 memset (die, 0, sizeof (struct die_info));
23926 /* Macro support. */
23928 /* Return file name relative to the compilation directory of file number I in
23929 *LH's file name table. The result is allocated using xmalloc; the caller is
23930 responsible for freeing it. */
23933 file_file_name (int file, struct line_header *lh)
23935 /* Is the file number a valid index into the line header's file name
23936 table? Remember that file numbers start with one, not zero. */
23937 if (1 <= file && file <= lh->file_names.size ())
23939 const file_entry &fe = lh->file_names[file - 1];
23941 if (!IS_ABSOLUTE_PATH (fe.name))
23943 const char *dir = fe.include_dir (lh);
23945 return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23947 return xstrdup (fe.name);
23951 /* The compiler produced a bogus file number. We can at least
23952 record the macro definitions made in the file, even if we
23953 won't be able to find the file by name. */
23954 char fake_name[80];
23956 xsnprintf (fake_name, sizeof (fake_name),
23957 "<bad macro file number %d>", file);
23959 complaint (&symfile_complaints,
23960 _("bad file number in macro information (%d)"),
23963 return xstrdup (fake_name);
23967 /* Return the full name of file number I in *LH's file name table.
23968 Use COMP_DIR as the name of the current directory of the
23969 compilation. The result is allocated using xmalloc; the caller is
23970 responsible for freeing it. */
23972 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23974 /* Is the file number a valid index into the line header's file name
23975 table? Remember that file numbers start with one, not zero. */
23976 if (1 <= file && file <= lh->file_names.size ())
23978 char *relative = file_file_name (file, lh);
23980 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23982 return reconcat (relative, comp_dir, SLASH_STRING,
23983 relative, (char *) NULL);
23986 return file_file_name (file, lh);
23990 static struct macro_source_file *
23991 macro_start_file (int file, int line,
23992 struct macro_source_file *current_file,
23993 struct line_header *lh)
23995 /* File name relative to the compilation directory of this source file. */
23996 char *file_name = file_file_name (file, lh);
23998 if (! current_file)
24000 /* Note: We don't create a macro table for this compilation unit
24001 at all until we actually get a filename. */
24002 struct macro_table *macro_table = get_macro_table ();
24004 /* If we have no current file, then this must be the start_file
24005 directive for the compilation unit's main source file. */
24006 current_file = macro_set_main (macro_table, file_name);
24007 macro_define_special (macro_table);
24010 current_file = macro_include (current_file, line, file_name);
24014 return current_file;
24017 static const char *
24018 consume_improper_spaces (const char *p, const char *body)
24022 complaint (&symfile_complaints,
24023 _("macro definition contains spaces "
24024 "in formal argument list:\n`%s'"),
24036 parse_macro_definition (struct macro_source_file *file, int line,
24041 /* The body string takes one of two forms. For object-like macro
24042 definitions, it should be:
24044 <macro name> " " <definition>
24046 For function-like macro definitions, it should be:
24048 <macro name> "() " <definition>
24050 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24052 Spaces may appear only where explicitly indicated, and in the
24055 The Dwarf 2 spec says that an object-like macro's name is always
24056 followed by a space, but versions of GCC around March 2002 omit
24057 the space when the macro's definition is the empty string.
24059 The Dwarf 2 spec says that there should be no spaces between the
24060 formal arguments in a function-like macro's formal argument list,
24061 but versions of GCC around March 2002 include spaces after the
24065 /* Find the extent of the macro name. The macro name is terminated
24066 by either a space or null character (for an object-like macro) or
24067 an opening paren (for a function-like macro). */
24068 for (p = body; *p; p++)
24069 if (*p == ' ' || *p == '(')
24072 if (*p == ' ' || *p == '\0')
24074 /* It's an object-like macro. */
24075 int name_len = p - body;
24076 char *name = savestring (body, name_len);
24077 const char *replacement;
24080 replacement = body + name_len + 1;
24083 dwarf2_macro_malformed_definition_complaint (body);
24084 replacement = body + name_len;
24087 macro_define_object (file, line, name, replacement);
24091 else if (*p == '(')
24093 /* It's a function-like macro. */
24094 char *name = savestring (body, p - body);
24097 char **argv = XNEWVEC (char *, argv_size);
24101 p = consume_improper_spaces (p, body);
24103 /* Parse the formal argument list. */
24104 while (*p && *p != ')')
24106 /* Find the extent of the current argument name. */
24107 const char *arg_start = p;
24109 while (*p && *p != ',' && *p != ')' && *p != ' ')
24112 if (! *p || p == arg_start)
24113 dwarf2_macro_malformed_definition_complaint (body);
24116 /* Make sure argv has room for the new argument. */
24117 if (argc >= argv_size)
24120 argv = XRESIZEVEC (char *, argv, argv_size);
24123 argv[argc++] = savestring (arg_start, p - arg_start);
24126 p = consume_improper_spaces (p, body);
24128 /* Consume the comma, if present. */
24133 p = consume_improper_spaces (p, body);
24142 /* Perfectly formed definition, no complaints. */
24143 macro_define_function (file, line, name,
24144 argc, (const char **) argv,
24146 else if (*p == '\0')
24148 /* Complain, but do define it. */
24149 dwarf2_macro_malformed_definition_complaint (body);
24150 macro_define_function (file, line, name,
24151 argc, (const char **) argv,
24155 /* Just complain. */
24156 dwarf2_macro_malformed_definition_complaint (body);
24159 /* Just complain. */
24160 dwarf2_macro_malformed_definition_complaint (body);
24166 for (i = 0; i < argc; i++)
24172 dwarf2_macro_malformed_definition_complaint (body);
24175 /* Skip some bytes from BYTES according to the form given in FORM.
24176 Returns the new pointer. */
24178 static const gdb_byte *
24179 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24180 enum dwarf_form form,
24181 unsigned int offset_size,
24182 struct dwarf2_section_info *section)
24184 unsigned int bytes_read;
24188 case DW_FORM_data1:
24193 case DW_FORM_data2:
24197 case DW_FORM_data4:
24201 case DW_FORM_data8:
24205 case DW_FORM_data16:
24209 case DW_FORM_string:
24210 read_direct_string (abfd, bytes, &bytes_read);
24211 bytes += bytes_read;
24214 case DW_FORM_sec_offset:
24216 case DW_FORM_GNU_strp_alt:
24217 bytes += offset_size;
24220 case DW_FORM_block:
24221 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24222 bytes += bytes_read;
24225 case DW_FORM_block1:
24226 bytes += 1 + read_1_byte (abfd, bytes);
24228 case DW_FORM_block2:
24229 bytes += 2 + read_2_bytes (abfd, bytes);
24231 case DW_FORM_block4:
24232 bytes += 4 + read_4_bytes (abfd, bytes);
24235 case DW_FORM_sdata:
24236 case DW_FORM_udata:
24237 case DW_FORM_GNU_addr_index:
24238 case DW_FORM_GNU_str_index:
24239 bytes = gdb_skip_leb128 (bytes, buffer_end);
24242 dwarf2_section_buffer_overflow_complaint (section);
24247 case DW_FORM_implicit_const:
24252 complaint (&symfile_complaints,
24253 _("invalid form 0x%x in `%s'"),
24254 form, get_section_name (section));
24262 /* A helper for dwarf_decode_macros that handles skipping an unknown
24263 opcode. Returns an updated pointer to the macro data buffer; or,
24264 on error, issues a complaint and returns NULL. */
24266 static const gdb_byte *
24267 skip_unknown_opcode (unsigned int opcode,
24268 const gdb_byte **opcode_definitions,
24269 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24271 unsigned int offset_size,
24272 struct dwarf2_section_info *section)
24274 unsigned int bytes_read, i;
24276 const gdb_byte *defn;
24278 if (opcode_definitions[opcode] == NULL)
24280 complaint (&symfile_complaints,
24281 _("unrecognized DW_MACFINO opcode 0x%x"),
24286 defn = opcode_definitions[opcode];
24287 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24288 defn += bytes_read;
24290 for (i = 0; i < arg; ++i)
24292 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24293 (enum dwarf_form) defn[i], offset_size,
24295 if (mac_ptr == NULL)
24297 /* skip_form_bytes already issued the complaint. */
24305 /* A helper function which parses the header of a macro section.
24306 If the macro section is the extended (for now called "GNU") type,
24307 then this updates *OFFSET_SIZE. Returns a pointer to just after
24308 the header, or issues a complaint and returns NULL on error. */
24310 static const gdb_byte *
24311 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24313 const gdb_byte *mac_ptr,
24314 unsigned int *offset_size,
24315 int section_is_gnu)
24317 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24319 if (section_is_gnu)
24321 unsigned int version, flags;
24323 version = read_2_bytes (abfd, mac_ptr);
24324 if (version != 4 && version != 5)
24326 complaint (&symfile_complaints,
24327 _("unrecognized version `%d' in .debug_macro section"),
24333 flags = read_1_byte (abfd, mac_ptr);
24335 *offset_size = (flags & 1) ? 8 : 4;
24337 if ((flags & 2) != 0)
24338 /* We don't need the line table offset. */
24339 mac_ptr += *offset_size;
24341 /* Vendor opcode descriptions. */
24342 if ((flags & 4) != 0)
24344 unsigned int i, count;
24346 count = read_1_byte (abfd, mac_ptr);
24348 for (i = 0; i < count; ++i)
24350 unsigned int opcode, bytes_read;
24353 opcode = read_1_byte (abfd, mac_ptr);
24355 opcode_definitions[opcode] = mac_ptr;
24356 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24357 mac_ptr += bytes_read;
24366 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24367 including DW_MACRO_import. */
24370 dwarf_decode_macro_bytes (struct dwarf2_per_objfile *dwarf2_per_objfile,
24372 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24373 struct macro_source_file *current_file,
24374 struct line_header *lh,
24375 struct dwarf2_section_info *section,
24376 int section_is_gnu, int section_is_dwz,
24377 unsigned int offset_size,
24378 htab_t include_hash)
24380 struct objfile *objfile = dwarf2_per_objfile->objfile;
24381 enum dwarf_macro_record_type macinfo_type;
24382 int at_commandline;
24383 const gdb_byte *opcode_definitions[256];
24385 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24386 &offset_size, section_is_gnu);
24387 if (mac_ptr == NULL)
24389 /* We already issued a complaint. */
24393 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24394 GDB is still reading the definitions from command line. First
24395 DW_MACINFO_start_file will need to be ignored as it was already executed
24396 to create CURRENT_FILE for the main source holding also the command line
24397 definitions. On first met DW_MACINFO_start_file this flag is reset to
24398 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24400 at_commandline = 1;
24404 /* Do we at least have room for a macinfo type byte? */
24405 if (mac_ptr >= mac_end)
24407 dwarf2_section_buffer_overflow_complaint (section);
24411 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24414 /* Note that we rely on the fact that the corresponding GNU and
24415 DWARF constants are the same. */
24417 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24418 switch (macinfo_type)
24420 /* A zero macinfo type indicates the end of the macro
24425 case DW_MACRO_define:
24426 case DW_MACRO_undef:
24427 case DW_MACRO_define_strp:
24428 case DW_MACRO_undef_strp:
24429 case DW_MACRO_define_sup:
24430 case DW_MACRO_undef_sup:
24432 unsigned int bytes_read;
24437 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24438 mac_ptr += bytes_read;
24440 if (macinfo_type == DW_MACRO_define
24441 || macinfo_type == DW_MACRO_undef)
24443 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24444 mac_ptr += bytes_read;
24448 LONGEST str_offset;
24450 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24451 mac_ptr += offset_size;
24453 if (macinfo_type == DW_MACRO_define_sup
24454 || macinfo_type == DW_MACRO_undef_sup
24457 struct dwz_file *dwz
24458 = dwarf2_get_dwz_file (dwarf2_per_objfile);
24460 body = read_indirect_string_from_dwz (objfile,
24464 body = read_indirect_string_at_offset (dwarf2_per_objfile,
24468 is_define = (macinfo_type == DW_MACRO_define
24469 || macinfo_type == DW_MACRO_define_strp
24470 || macinfo_type == DW_MACRO_define_sup);
24471 if (! current_file)
24473 /* DWARF violation as no main source is present. */
24474 complaint (&symfile_complaints,
24475 _("debug info with no main source gives macro %s "
24477 is_define ? _("definition") : _("undefinition"),
24481 if ((line == 0 && !at_commandline)
24482 || (line != 0 && at_commandline))
24483 complaint (&symfile_complaints,
24484 _("debug info gives %s macro %s with %s line %d: %s"),
24485 at_commandline ? _("command-line") : _("in-file"),
24486 is_define ? _("definition") : _("undefinition"),
24487 line == 0 ? _("zero") : _("non-zero"), line, body);
24490 parse_macro_definition (current_file, line, body);
24493 gdb_assert (macinfo_type == DW_MACRO_undef
24494 || macinfo_type == DW_MACRO_undef_strp
24495 || macinfo_type == DW_MACRO_undef_sup);
24496 macro_undef (current_file, line, body);
24501 case DW_MACRO_start_file:
24503 unsigned int bytes_read;
24506 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24507 mac_ptr += bytes_read;
24508 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24509 mac_ptr += bytes_read;
24511 if ((line == 0 && !at_commandline)
24512 || (line != 0 && at_commandline))
24513 complaint (&symfile_complaints,
24514 _("debug info gives source %d included "
24515 "from %s at %s line %d"),
24516 file, at_commandline ? _("command-line") : _("file"),
24517 line == 0 ? _("zero") : _("non-zero"), line);
24519 if (at_commandline)
24521 /* This DW_MACRO_start_file was executed in the
24523 at_commandline = 0;
24526 current_file = macro_start_file (file, line, current_file, lh);
24530 case DW_MACRO_end_file:
24531 if (! current_file)
24532 complaint (&symfile_complaints,
24533 _("macro debug info has an unmatched "
24534 "`close_file' directive"));
24537 current_file = current_file->included_by;
24538 if (! current_file)
24540 enum dwarf_macro_record_type next_type;
24542 /* GCC circa March 2002 doesn't produce the zero
24543 type byte marking the end of the compilation
24544 unit. Complain if it's not there, but exit no
24547 /* Do we at least have room for a macinfo type byte? */
24548 if (mac_ptr >= mac_end)
24550 dwarf2_section_buffer_overflow_complaint (section);
24554 /* We don't increment mac_ptr here, so this is just
24557 = (enum dwarf_macro_record_type) read_1_byte (abfd,
24559 if (next_type != 0)
24560 complaint (&symfile_complaints,
24561 _("no terminating 0-type entry for "
24562 "macros in `.debug_macinfo' section"));
24569 case DW_MACRO_import:
24570 case DW_MACRO_import_sup:
24574 bfd *include_bfd = abfd;
24575 struct dwarf2_section_info *include_section = section;
24576 const gdb_byte *include_mac_end = mac_end;
24577 int is_dwz = section_is_dwz;
24578 const gdb_byte *new_mac_ptr;
24580 offset = read_offset_1 (abfd, mac_ptr, offset_size);
24581 mac_ptr += offset_size;
24583 if (macinfo_type == DW_MACRO_import_sup)
24585 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24587 dwarf2_read_section (objfile, &dwz->macro);
24589 include_section = &dwz->macro;
24590 include_bfd = get_section_bfd_owner (include_section);
24591 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24595 new_mac_ptr = include_section->buffer + offset;
24596 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24600 /* This has actually happened; see
24601 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24602 complaint (&symfile_complaints,
24603 _("recursive DW_MACRO_import in "
24604 ".debug_macro section"));
24608 *slot = (void *) new_mac_ptr;
24610 dwarf_decode_macro_bytes (dwarf2_per_objfile,
24611 include_bfd, new_mac_ptr,
24612 include_mac_end, current_file, lh,
24613 section, section_is_gnu, is_dwz,
24614 offset_size, include_hash);
24616 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24621 case DW_MACINFO_vendor_ext:
24622 if (!section_is_gnu)
24624 unsigned int bytes_read;
24626 /* This reads the constant, but since we don't recognize
24627 any vendor extensions, we ignore it. */
24628 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24629 mac_ptr += bytes_read;
24630 read_direct_string (abfd, mac_ptr, &bytes_read);
24631 mac_ptr += bytes_read;
24633 /* We don't recognize any vendor extensions. */
24639 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24640 mac_ptr, mac_end, abfd, offset_size,
24642 if (mac_ptr == NULL)
24647 } while (macinfo_type != 0);
24651 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24652 int section_is_gnu)
24654 struct dwarf2_per_objfile *dwarf2_per_objfile
24655 = cu->per_cu->dwarf2_per_objfile;
24656 struct objfile *objfile = dwarf2_per_objfile->objfile;
24657 struct line_header *lh = cu->line_header;
24659 const gdb_byte *mac_ptr, *mac_end;
24660 struct macro_source_file *current_file = 0;
24661 enum dwarf_macro_record_type macinfo_type;
24662 unsigned int offset_size = cu->header.offset_size;
24663 const gdb_byte *opcode_definitions[256];
24665 struct dwarf2_section_info *section;
24666 const char *section_name;
24668 if (cu->dwo_unit != NULL)
24670 if (section_is_gnu)
24672 section = &cu->dwo_unit->dwo_file->sections.macro;
24673 section_name = ".debug_macro.dwo";
24677 section = &cu->dwo_unit->dwo_file->sections.macinfo;
24678 section_name = ".debug_macinfo.dwo";
24683 if (section_is_gnu)
24685 section = &dwarf2_per_objfile->macro;
24686 section_name = ".debug_macro";
24690 section = &dwarf2_per_objfile->macinfo;
24691 section_name = ".debug_macinfo";
24695 dwarf2_read_section (objfile, section);
24696 if (section->buffer == NULL)
24698 complaint (&symfile_complaints, _("missing %s section"), section_name);
24701 abfd = get_section_bfd_owner (section);
24703 /* First pass: Find the name of the base filename.
24704 This filename is needed in order to process all macros whose definition
24705 (or undefinition) comes from the command line. These macros are defined
24706 before the first DW_MACINFO_start_file entry, and yet still need to be
24707 associated to the base file.
24709 To determine the base file name, we scan the macro definitions until we
24710 reach the first DW_MACINFO_start_file entry. We then initialize
24711 CURRENT_FILE accordingly so that any macro definition found before the
24712 first DW_MACINFO_start_file can still be associated to the base file. */
24714 mac_ptr = section->buffer + offset;
24715 mac_end = section->buffer + section->size;
24717 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24718 &offset_size, section_is_gnu);
24719 if (mac_ptr == NULL)
24721 /* We already issued a complaint. */
24727 /* Do we at least have room for a macinfo type byte? */
24728 if (mac_ptr >= mac_end)
24730 /* Complaint is printed during the second pass as GDB will probably
24731 stop the first pass earlier upon finding
24732 DW_MACINFO_start_file. */
24736 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24739 /* Note that we rely on the fact that the corresponding GNU and
24740 DWARF constants are the same. */
24742 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24743 switch (macinfo_type)
24745 /* A zero macinfo type indicates the end of the macro
24750 case DW_MACRO_define:
24751 case DW_MACRO_undef:
24752 /* Only skip the data by MAC_PTR. */
24754 unsigned int bytes_read;
24756 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24757 mac_ptr += bytes_read;
24758 read_direct_string (abfd, mac_ptr, &bytes_read);
24759 mac_ptr += bytes_read;
24763 case DW_MACRO_start_file:
24765 unsigned int bytes_read;
24768 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24769 mac_ptr += bytes_read;
24770 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24771 mac_ptr += bytes_read;
24773 current_file = macro_start_file (file, line, current_file, lh);
24777 case DW_MACRO_end_file:
24778 /* No data to skip by MAC_PTR. */
24781 case DW_MACRO_define_strp:
24782 case DW_MACRO_undef_strp:
24783 case DW_MACRO_define_sup:
24784 case DW_MACRO_undef_sup:
24786 unsigned int bytes_read;
24788 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24789 mac_ptr += bytes_read;
24790 mac_ptr += offset_size;
24794 case DW_MACRO_import:
24795 case DW_MACRO_import_sup:
24796 /* Note that, according to the spec, a transparent include
24797 chain cannot call DW_MACRO_start_file. So, we can just
24798 skip this opcode. */
24799 mac_ptr += offset_size;
24802 case DW_MACINFO_vendor_ext:
24803 /* Only skip the data by MAC_PTR. */
24804 if (!section_is_gnu)
24806 unsigned int bytes_read;
24808 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24809 mac_ptr += bytes_read;
24810 read_direct_string (abfd, mac_ptr, &bytes_read);
24811 mac_ptr += bytes_read;
24816 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24817 mac_ptr, mac_end, abfd, offset_size,
24819 if (mac_ptr == NULL)
24824 } while (macinfo_type != 0 && current_file == NULL);
24826 /* Second pass: Process all entries.
24828 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24829 command-line macro definitions/undefinitions. This flag is unset when we
24830 reach the first DW_MACINFO_start_file entry. */
24832 htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24834 NULL, xcalloc, xfree));
24835 mac_ptr = section->buffer + offset;
24836 slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24837 *slot = (void *) mac_ptr;
24838 dwarf_decode_macro_bytes (dwarf2_per_objfile,
24839 abfd, mac_ptr, mac_end,
24840 current_file, lh, section,
24841 section_is_gnu, 0, offset_size,
24842 include_hash.get ());
24845 /* Check if the attribute's form is a DW_FORM_block*
24846 if so return true else false. */
24849 attr_form_is_block (const struct attribute *attr)
24851 return (attr == NULL ? 0 :
24852 attr->form == DW_FORM_block1
24853 || attr->form == DW_FORM_block2
24854 || attr->form == DW_FORM_block4
24855 || attr->form == DW_FORM_block
24856 || attr->form == DW_FORM_exprloc);
24859 /* Return non-zero if ATTR's value is a section offset --- classes
24860 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24861 You may use DW_UNSND (attr) to retrieve such offsets.
24863 Section 7.5.4, "Attribute Encodings", explains that no attribute
24864 may have a value that belongs to more than one of these classes; it
24865 would be ambiguous if we did, because we use the same forms for all
24869 attr_form_is_section_offset (const struct attribute *attr)
24871 return (attr->form == DW_FORM_data4
24872 || attr->form == DW_FORM_data8
24873 || attr->form == DW_FORM_sec_offset);
24876 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24877 zero otherwise. When this function returns true, you can apply
24878 dwarf2_get_attr_constant_value to it.
24880 However, note that for some attributes you must check
24881 attr_form_is_section_offset before using this test. DW_FORM_data4
24882 and DW_FORM_data8 are members of both the constant class, and of
24883 the classes that contain offsets into other debug sections
24884 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
24885 that, if an attribute's can be either a constant or one of the
24886 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24887 taken as section offsets, not constants.
24889 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24890 cannot handle that. */
24893 attr_form_is_constant (const struct attribute *attr)
24895 switch (attr->form)
24897 case DW_FORM_sdata:
24898 case DW_FORM_udata:
24899 case DW_FORM_data1:
24900 case DW_FORM_data2:
24901 case DW_FORM_data4:
24902 case DW_FORM_data8:
24903 case DW_FORM_implicit_const:
24911 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24912 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
24915 attr_form_is_ref (const struct attribute *attr)
24917 switch (attr->form)
24919 case DW_FORM_ref_addr:
24924 case DW_FORM_ref_udata:
24925 case DW_FORM_GNU_ref_alt:
24932 /* Return the .debug_loc section to use for CU.
24933 For DWO files use .debug_loc.dwo. */
24935 static struct dwarf2_section_info *
24936 cu_debug_loc_section (struct dwarf2_cu *cu)
24938 struct dwarf2_per_objfile *dwarf2_per_objfile
24939 = cu->per_cu->dwarf2_per_objfile;
24943 struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24945 return cu->header.version >= 5 ? §ions->loclists : §ions->loc;
24947 return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24948 : &dwarf2_per_objfile->loc);
24951 /* A helper function that fills in a dwarf2_loclist_baton. */
24954 fill_in_loclist_baton (struct dwarf2_cu *cu,
24955 struct dwarf2_loclist_baton *baton,
24956 const struct attribute *attr)
24958 struct dwarf2_per_objfile *dwarf2_per_objfile
24959 = cu->per_cu->dwarf2_per_objfile;
24960 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24962 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24964 baton->per_cu = cu->per_cu;
24965 gdb_assert (baton->per_cu);
24966 /* We don't know how long the location list is, but make sure we
24967 don't run off the edge of the section. */
24968 baton->size = section->size - DW_UNSND (attr);
24969 baton->data = section->buffer + DW_UNSND (attr);
24970 baton->base_address = cu->base_address;
24971 baton->from_dwo = cu->dwo_unit != NULL;
24975 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24976 struct dwarf2_cu *cu, int is_block)
24978 struct dwarf2_per_objfile *dwarf2_per_objfile
24979 = cu->per_cu->dwarf2_per_objfile;
24980 struct objfile *objfile = dwarf2_per_objfile->objfile;
24981 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24983 if (attr_form_is_section_offset (attr)
24984 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24985 the section. If so, fall through to the complaint in the
24987 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24989 struct dwarf2_loclist_baton *baton;
24991 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24993 fill_in_loclist_baton (cu, baton, attr);
24995 if (cu->base_known == 0)
24996 complaint (&symfile_complaints,
24997 _("Location list used without "
24998 "specifying the CU base address."));
25000 SYMBOL_ACLASS_INDEX (sym) = (is_block
25001 ? dwarf2_loclist_block_index
25002 : dwarf2_loclist_index);
25003 SYMBOL_LOCATION_BATON (sym) = baton;
25007 struct dwarf2_locexpr_baton *baton;
25009 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
25010 baton->per_cu = cu->per_cu;
25011 gdb_assert (baton->per_cu);
25013 if (attr_form_is_block (attr))
25015 /* Note that we're just copying the block's data pointer
25016 here, not the actual data. We're still pointing into the
25017 info_buffer for SYM's objfile; right now we never release
25018 that buffer, but when we do clean up properly this may
25020 baton->size = DW_BLOCK (attr)->size;
25021 baton->data = DW_BLOCK (attr)->data;
25025 dwarf2_invalid_attrib_class_complaint ("location description",
25026 SYMBOL_NATURAL_NAME (sym));
25030 SYMBOL_ACLASS_INDEX (sym) = (is_block
25031 ? dwarf2_locexpr_block_index
25032 : dwarf2_locexpr_index);
25033 SYMBOL_LOCATION_BATON (sym) = baton;
25037 /* Return the OBJFILE associated with the compilation unit CU. If CU
25038 came from a separate debuginfo file, then the master objfile is
25042 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25044 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25046 /* Return the master objfile, so that we can report and look up the
25047 correct file containing this variable. */
25048 if (objfile->separate_debug_objfile_backlink)
25049 objfile = objfile->separate_debug_objfile_backlink;
25054 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25055 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25056 CU_HEADERP first. */
25058 static const struct comp_unit_head *
25059 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25060 struct dwarf2_per_cu_data *per_cu)
25062 const gdb_byte *info_ptr;
25065 return &per_cu->cu->header;
25067 info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25069 memset (cu_headerp, 0, sizeof (*cu_headerp));
25070 read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25071 rcuh_kind::COMPILE);
25076 /* Return the address size given in the compilation unit header for CU. */
25079 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25081 struct comp_unit_head cu_header_local;
25082 const struct comp_unit_head *cu_headerp;
25084 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25086 return cu_headerp->addr_size;
25089 /* Return the offset size given in the compilation unit header for CU. */
25092 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25094 struct comp_unit_head cu_header_local;
25095 const struct comp_unit_head *cu_headerp;
25097 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25099 return cu_headerp->offset_size;
25102 /* See its dwarf2loc.h declaration. */
25105 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25107 struct comp_unit_head cu_header_local;
25108 const struct comp_unit_head *cu_headerp;
25110 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25112 if (cu_headerp->version == 2)
25113 return cu_headerp->addr_size;
25115 return cu_headerp->offset_size;
25118 /* Return the text offset of the CU. The returned offset comes from
25119 this CU's objfile. If this objfile came from a separate debuginfo
25120 file, then the offset may be different from the corresponding
25121 offset in the parent objfile. */
25124 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25126 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25128 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25131 /* Return DWARF version number of PER_CU. */
25134 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25136 return per_cu->dwarf_version;
25139 /* Locate the .debug_info compilation unit from CU's objfile which contains
25140 the DIE at OFFSET. Raises an error on failure. */
25142 static struct dwarf2_per_cu_data *
25143 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25144 unsigned int offset_in_dwz,
25145 struct dwarf2_per_objfile *dwarf2_per_objfile)
25147 struct dwarf2_per_cu_data *this_cu;
25149 const sect_offset *cu_off;
25152 high = dwarf2_per_objfile->n_comp_units - 1;
25155 struct dwarf2_per_cu_data *mid_cu;
25156 int mid = low + (high - low) / 2;
25158 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25159 cu_off = &mid_cu->sect_off;
25160 if (mid_cu->is_dwz > offset_in_dwz
25161 || (mid_cu->is_dwz == offset_in_dwz && *cu_off >= sect_off))
25166 gdb_assert (low == high);
25167 this_cu = dwarf2_per_objfile->all_comp_units[low];
25168 cu_off = &this_cu->sect_off;
25169 if (this_cu->is_dwz != offset_in_dwz || *cu_off > sect_off)
25171 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25172 error (_("Dwarf Error: could not find partial DIE containing "
25173 "offset 0x%x [in module %s]"),
25174 to_underlying (sect_off),
25175 bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25177 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25179 return dwarf2_per_objfile->all_comp_units[low-1];
25183 this_cu = dwarf2_per_objfile->all_comp_units[low];
25184 if (low == dwarf2_per_objfile->n_comp_units - 1
25185 && sect_off >= this_cu->sect_off + this_cu->length)
25186 error (_("invalid dwarf2 offset %u"), to_underlying (sect_off));
25187 gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25192 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25195 init_one_comp_unit (struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
25197 memset (cu, 0, sizeof (*cu));
25199 cu->per_cu = per_cu;
25200 obstack_init (&cu->comp_unit_obstack);
25203 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25206 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25207 enum language pretend_language)
25209 struct attribute *attr;
25211 /* Set the language we're debugging. */
25212 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25214 set_cu_language (DW_UNSND (attr), cu);
25217 cu->language = pretend_language;
25218 cu->language_defn = language_def (cu->language);
25221 cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25224 /* Release one cached compilation unit, CU. We unlink it from the tree
25225 of compilation units, but we don't remove it from the read_in_chain;
25226 the caller is responsible for that.
25227 NOTE: DATA is a void * because this function is also used as a
25228 cleanup routine. */
25231 free_heap_comp_unit (void *data)
25233 struct dwarf2_cu *cu = (struct dwarf2_cu *) data;
25235 gdb_assert (cu->per_cu != NULL);
25236 cu->per_cu->cu = NULL;
25239 obstack_free (&cu->comp_unit_obstack, NULL);
25244 /* This cleanup function is passed the address of a dwarf2_cu on the stack
25245 when we're finished with it. We can't free the pointer itself, but be
25246 sure to unlink it from the cache. Also release any associated storage. */
25249 free_stack_comp_unit (void *data)
25251 struct dwarf2_cu *cu = (struct dwarf2_cu *) data;
25253 gdb_assert (cu->per_cu != NULL);
25254 cu->per_cu->cu = NULL;
25257 obstack_free (&cu->comp_unit_obstack, NULL);
25258 cu->partial_dies = NULL;
25261 /* Free all cached compilation units. */
25264 free_cached_comp_units (void *data)
25266 struct dwarf2_per_objfile *dwarf2_per_objfile
25267 = (struct dwarf2_per_objfile *) data;
25269 dwarf2_per_objfile->free_cached_comp_units ();
25272 /* Increase the age counter on each cached compilation unit, and free
25273 any that are too old. */
25276 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25278 struct dwarf2_per_cu_data *per_cu, **last_chain;
25280 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25281 per_cu = dwarf2_per_objfile->read_in_chain;
25282 while (per_cu != NULL)
25284 per_cu->cu->last_used ++;
25285 if (per_cu->cu->last_used <= dwarf_max_cache_age)
25286 dwarf2_mark (per_cu->cu);
25287 per_cu = per_cu->cu->read_in_chain;
25290 per_cu = dwarf2_per_objfile->read_in_chain;
25291 last_chain = &dwarf2_per_objfile->read_in_chain;
25292 while (per_cu != NULL)
25294 struct dwarf2_per_cu_data *next_cu;
25296 next_cu = per_cu->cu->read_in_chain;
25298 if (!per_cu->cu->mark)
25300 free_heap_comp_unit (per_cu->cu);
25301 *last_chain = next_cu;
25304 last_chain = &per_cu->cu->read_in_chain;
25310 /* Remove a single compilation unit from the cache. */
25313 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25315 struct dwarf2_per_cu_data *per_cu, **last_chain;
25316 struct dwarf2_per_objfile *dwarf2_per_objfile
25317 = target_per_cu->dwarf2_per_objfile;
25319 per_cu = dwarf2_per_objfile->read_in_chain;
25320 last_chain = &dwarf2_per_objfile->read_in_chain;
25321 while (per_cu != NULL)
25323 struct dwarf2_per_cu_data *next_cu;
25325 next_cu = per_cu->cu->read_in_chain;
25327 if (per_cu == target_per_cu)
25329 free_heap_comp_unit (per_cu->cu);
25331 *last_chain = next_cu;
25335 last_chain = &per_cu->cu->read_in_chain;
25341 /* Release all extra memory associated with OBJFILE. */
25344 dwarf2_free_objfile (struct objfile *objfile)
25346 struct dwarf2_per_objfile *dwarf2_per_objfile
25347 = get_dwarf2_per_objfile (objfile);
25349 if (dwarf2_per_objfile == NULL)
25352 dwarf2_per_objfile->~dwarf2_per_objfile ();
25355 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25356 We store these in a hash table separate from the DIEs, and preserve them
25357 when the DIEs are flushed out of cache.
25359 The CU "per_cu" pointer is needed because offset alone is not enough to
25360 uniquely identify the type. A file may have multiple .debug_types sections,
25361 or the type may come from a DWO file. Furthermore, while it's more logical
25362 to use per_cu->section+offset, with Fission the section with the data is in
25363 the DWO file but we don't know that section at the point we need it.
25364 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25365 because we can enter the lookup routine, get_die_type_at_offset, from
25366 outside this file, and thus won't necessarily have PER_CU->cu.
25367 Fortunately, PER_CU is stable for the life of the objfile. */
25369 struct dwarf2_per_cu_offset_and_type
25371 const struct dwarf2_per_cu_data *per_cu;
25372 sect_offset sect_off;
25376 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25379 per_cu_offset_and_type_hash (const void *item)
25381 const struct dwarf2_per_cu_offset_and_type *ofs
25382 = (const struct dwarf2_per_cu_offset_and_type *) item;
25384 return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25387 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25390 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25392 const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25393 = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25394 const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25395 = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25397 return (ofs_lhs->per_cu == ofs_rhs->per_cu
25398 && ofs_lhs->sect_off == ofs_rhs->sect_off);
25401 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25402 table if necessary. For convenience, return TYPE.
25404 The DIEs reading must have careful ordering to:
25405 * Not cause infite loops trying to read in DIEs as a prerequisite for
25406 reading current DIE.
25407 * Not trying to dereference contents of still incompletely read in types
25408 while reading in other DIEs.
25409 * Enable referencing still incompletely read in types just by a pointer to
25410 the type without accessing its fields.
25412 Therefore caller should follow these rules:
25413 * Try to fetch any prerequisite types we may need to build this DIE type
25414 before building the type and calling set_die_type.
25415 * After building type call set_die_type for current DIE as soon as
25416 possible before fetching more types to complete the current type.
25417 * Make the type as complete as possible before fetching more types. */
25419 static struct type *
25420 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25422 struct dwarf2_per_objfile *dwarf2_per_objfile
25423 = cu->per_cu->dwarf2_per_objfile;
25424 struct dwarf2_per_cu_offset_and_type **slot, ofs;
25425 struct objfile *objfile = dwarf2_per_objfile->objfile;
25426 struct attribute *attr;
25427 struct dynamic_prop prop;
25429 /* For Ada types, make sure that the gnat-specific data is always
25430 initialized (if not already set). There are a few types where
25431 we should not be doing so, because the type-specific area is
25432 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25433 where the type-specific area is used to store the floatformat).
25434 But this is not a problem, because the gnat-specific information
25435 is actually not needed for these types. */
25436 if (need_gnat_info (cu)
25437 && TYPE_CODE (type) != TYPE_CODE_FUNC
25438 && TYPE_CODE (type) != TYPE_CODE_FLT
25439 && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25440 && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25441 && TYPE_CODE (type) != TYPE_CODE_METHOD
25442 && !HAVE_GNAT_AUX_INFO (type))
25443 INIT_GNAT_SPECIFIC (type);
25445 /* Read DW_AT_allocated and set in type. */
25446 attr = dwarf2_attr (die, DW_AT_allocated, cu);
25447 if (attr_form_is_block (attr))
25449 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25450 add_dyn_prop (DYN_PROP_ALLOCATED, prop, type, objfile);
25452 else if (attr != NULL)
25454 complaint (&symfile_complaints,
25455 _("DW_AT_allocated has the wrong form (%s) at DIE 0x%x"),
25456 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25457 to_underlying (die->sect_off));
25460 /* Read DW_AT_associated and set in type. */
25461 attr = dwarf2_attr (die, DW_AT_associated, cu);
25462 if (attr_form_is_block (attr))
25464 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25465 add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type, objfile);
25467 else if (attr != NULL)
25469 complaint (&symfile_complaints,
25470 _("DW_AT_associated has the wrong form (%s) at DIE 0x%x"),
25471 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25472 to_underlying (die->sect_off));
25475 /* Read DW_AT_data_location and set in type. */
25476 attr = dwarf2_attr (die, DW_AT_data_location, cu);
25477 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25478 add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type, objfile);
25480 if (dwarf2_per_objfile->die_type_hash == NULL)
25482 dwarf2_per_objfile->die_type_hash =
25483 htab_create_alloc_ex (127,
25484 per_cu_offset_and_type_hash,
25485 per_cu_offset_and_type_eq,
25487 &objfile->objfile_obstack,
25488 hashtab_obstack_allocate,
25489 dummy_obstack_deallocate);
25492 ofs.per_cu = cu->per_cu;
25493 ofs.sect_off = die->sect_off;
25495 slot = (struct dwarf2_per_cu_offset_and_type **)
25496 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25498 complaint (&symfile_complaints,
25499 _("A problem internal to GDB: DIE 0x%x has type already set"),
25500 to_underlying (die->sect_off));
25501 *slot = XOBNEW (&objfile->objfile_obstack,
25502 struct dwarf2_per_cu_offset_and_type);
25507 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25508 or return NULL if the die does not have a saved type. */
25510 static struct type *
25511 get_die_type_at_offset (sect_offset sect_off,
25512 struct dwarf2_per_cu_data *per_cu)
25514 struct dwarf2_per_cu_offset_and_type *slot, ofs;
25515 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25517 if (dwarf2_per_objfile->die_type_hash == NULL)
25520 ofs.per_cu = per_cu;
25521 ofs.sect_off = sect_off;
25522 slot = ((struct dwarf2_per_cu_offset_and_type *)
25523 htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25530 /* Look up the type for DIE in CU in die_type_hash,
25531 or return NULL if DIE does not have a saved type. */
25533 static struct type *
25534 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25536 return get_die_type_at_offset (die->sect_off, cu->per_cu);
25539 /* Add a dependence relationship from CU to REF_PER_CU. */
25542 dwarf2_add_dependence (struct dwarf2_cu *cu,
25543 struct dwarf2_per_cu_data *ref_per_cu)
25547 if (cu->dependencies == NULL)
25549 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25550 NULL, &cu->comp_unit_obstack,
25551 hashtab_obstack_allocate,
25552 dummy_obstack_deallocate);
25554 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25556 *slot = ref_per_cu;
25559 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25560 Set the mark field in every compilation unit in the
25561 cache that we must keep because we are keeping CU. */
25564 dwarf2_mark_helper (void **slot, void *data)
25566 struct dwarf2_per_cu_data *per_cu;
25568 per_cu = (struct dwarf2_per_cu_data *) *slot;
25570 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25571 reading of the chain. As such dependencies remain valid it is not much
25572 useful to track and undo them during QUIT cleanups. */
25573 if (per_cu->cu == NULL)
25576 if (per_cu->cu->mark)
25578 per_cu->cu->mark = 1;
25580 if (per_cu->cu->dependencies != NULL)
25581 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25586 /* Set the mark field in CU and in every other compilation unit in the
25587 cache that we must keep because we are keeping CU. */
25590 dwarf2_mark (struct dwarf2_cu *cu)
25595 if (cu->dependencies != NULL)
25596 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25600 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25604 per_cu->cu->mark = 0;
25605 per_cu = per_cu->cu->read_in_chain;
25609 /* Trivial hash function for partial_die_info: the hash value of a DIE
25610 is its offset in .debug_info for this objfile. */
25613 partial_die_hash (const void *item)
25615 const struct partial_die_info *part_die
25616 = (const struct partial_die_info *) item;
25618 return to_underlying (part_die->sect_off);
25621 /* Trivial comparison function for partial_die_info structures: two DIEs
25622 are equal if they have the same offset. */
25625 partial_die_eq (const void *item_lhs, const void *item_rhs)
25627 const struct partial_die_info *part_die_lhs
25628 = (const struct partial_die_info *) item_lhs;
25629 const struct partial_die_info *part_die_rhs
25630 = (const struct partial_die_info *) item_rhs;
25632 return part_die_lhs->sect_off == part_die_rhs->sect_off;
25635 static struct cmd_list_element *set_dwarf_cmdlist;
25636 static struct cmd_list_element *show_dwarf_cmdlist;
25639 set_dwarf_cmd (const char *args, int from_tty)
25641 help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25646 show_dwarf_cmd (const char *args, int from_tty)
25648 cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25651 /* Free data associated with OBJFILE, if necessary. */
25654 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
25656 struct dwarf2_per_objfile *data = (struct dwarf2_per_objfile *) d;
25659 for (ix = 0; ix < data->n_comp_units; ++ix)
25660 VEC_free (dwarf2_per_cu_ptr, data->all_comp_units[ix]->imported_symtabs);
25662 for (ix = 0; ix < data->n_type_units; ++ix)
25663 VEC_free (dwarf2_per_cu_ptr,
25664 data->all_type_units[ix]->per_cu.imported_symtabs);
25665 xfree (data->all_type_units);
25667 VEC_free (dwarf2_section_info_def, data->types);
25669 if (data->dwo_files)
25670 free_dwo_files (data->dwo_files, objfile);
25671 if (data->dwp_file)
25672 gdb_bfd_unref (data->dwp_file->dbfd);
25674 if (data->dwz_file && data->dwz_file->dwz_bfd)
25675 gdb_bfd_unref (data->dwz_file->dwz_bfd);
25677 if (data->index_table != NULL)
25678 data->index_table->~mapped_index ();
25682 /* The "save gdb-index" command. */
25684 /* Write SIZE bytes from the buffer pointed to by DATA to FILE, with
25688 file_write (FILE *file, const void *data, size_t size)
25690 if (fwrite (data, 1, size, file) != size)
25691 error (_("couldn't data write to file"));
25694 /* Write the contents of VEC to FILE, with error checking. */
25696 template<typename Elem, typename Alloc>
25698 file_write (FILE *file, const std::vector<Elem, Alloc> &vec)
25700 file_write (file, vec.data (), vec.size () * sizeof (vec[0]));
25703 /* In-memory buffer to prepare data to be written later to a file. */
25707 /* Copy DATA to the end of the buffer. */
25708 template<typename T>
25709 void append_data (const T &data)
25711 std::copy (reinterpret_cast<const gdb_byte *> (&data),
25712 reinterpret_cast<const gdb_byte *> (&data + 1),
25713 grow (sizeof (data)));
25716 /* Copy CSTR (a zero-terminated string) to the end of buffer. The
25717 terminating zero is appended too. */
25718 void append_cstr0 (const char *cstr)
25720 const size_t size = strlen (cstr) + 1;
25721 std::copy (cstr, cstr + size, grow (size));
25724 /* Store INPUT as ULEB128 to the end of buffer. */
25725 void append_unsigned_leb128 (ULONGEST input)
25729 gdb_byte output = input & 0x7f;
25733 append_data (output);
25739 /* Accept a host-format integer in VAL and append it to the buffer
25740 as a target-format integer which is LEN bytes long. */
25741 void append_uint (size_t len, bfd_endian byte_order, ULONGEST val)
25743 ::store_unsigned_integer (grow (len), len, byte_order, val);
25746 /* Return the size of the buffer. */
25747 size_t size () const
25749 return m_vec.size ();
25752 /* Return true iff the buffer is empty. */
25753 bool empty () const
25755 return m_vec.empty ();
25758 /* Write the buffer to FILE. */
25759 void file_write (FILE *file) const
25761 ::file_write (file, m_vec);
25765 /* Grow SIZE bytes at the end of the buffer. Returns a pointer to
25766 the start of the new block. */
25767 gdb_byte *grow (size_t size)
25769 m_vec.resize (m_vec.size () + size);
25770 return &*m_vec.end () - size;
25773 gdb::byte_vector m_vec;
25776 /* An entry in the symbol table. */
25777 struct symtab_index_entry
25779 /* The name of the symbol. */
25781 /* The offset of the name in the constant pool. */
25782 offset_type index_offset;
25783 /* A sorted vector of the indices of all the CUs that hold an object
25785 std::vector<offset_type> cu_indices;
25788 /* The symbol table. This is a power-of-2-sized hash table. */
25789 struct mapped_symtab
25793 data.resize (1024);
25796 offset_type n_elements = 0;
25797 std::vector<symtab_index_entry> data;
25800 /* Find a slot in SYMTAB for the symbol NAME. Returns a reference to
25803 Function is used only during write_hash_table so no index format backward
25804 compatibility is needed. */
25806 static symtab_index_entry &
25807 find_slot (struct mapped_symtab *symtab, const char *name)
25809 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
25811 index = hash & (symtab->data.size () - 1);
25812 step = ((hash * 17) & (symtab->data.size () - 1)) | 1;
25816 if (symtab->data[index].name == NULL
25817 || strcmp (name, symtab->data[index].name) == 0)
25818 return symtab->data[index];
25819 index = (index + step) & (symtab->data.size () - 1);
25823 /* Expand SYMTAB's hash table. */
25826 hash_expand (struct mapped_symtab *symtab)
25828 auto old_entries = std::move (symtab->data);
25830 symtab->data.clear ();
25831 symtab->data.resize (old_entries.size () * 2);
25833 for (auto &it : old_entries)
25834 if (it.name != NULL)
25836 auto &ref = find_slot (symtab, it.name);
25837 ref = std::move (it);
25841 /* Add an entry to SYMTAB. NAME is the name of the symbol.
25842 CU_INDEX is the index of the CU in which the symbol appears.
25843 IS_STATIC is one if the symbol is static, otherwise zero (global). */
25846 add_index_entry (struct mapped_symtab *symtab, const char *name,
25847 int is_static, gdb_index_symbol_kind kind,
25848 offset_type cu_index)
25850 offset_type cu_index_and_attrs;
25852 ++symtab->n_elements;
25853 if (4 * symtab->n_elements / 3 >= symtab->data.size ())
25854 hash_expand (symtab);
25856 symtab_index_entry &slot = find_slot (symtab, name);
25857 if (slot.name == NULL)
25860 /* index_offset is set later. */
25863 cu_index_and_attrs = 0;
25864 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
25865 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
25866 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
25868 /* We don't want to record an index value twice as we want to avoid the
25870 We process all global symbols and then all static symbols
25871 (which would allow us to avoid the duplication by only having to check
25872 the last entry pushed), but a symbol could have multiple kinds in one CU.
25873 To keep things simple we don't worry about the duplication here and
25874 sort and uniqufy the list after we've processed all symbols. */
25875 slot.cu_indices.push_back (cu_index_and_attrs);
25878 /* Sort and remove duplicates of all symbols' cu_indices lists. */
25881 uniquify_cu_indices (struct mapped_symtab *symtab)
25883 for (auto &entry : symtab->data)
25885 if (entry.name != NULL && !entry.cu_indices.empty ())
25887 auto &cu_indices = entry.cu_indices;
25888 std::sort (cu_indices.begin (), cu_indices.end ());
25889 auto from = std::unique (cu_indices.begin (), cu_indices.end ());
25890 cu_indices.erase (from, cu_indices.end ());
25895 /* A form of 'const char *' suitable for container keys. Only the
25896 pointer is stored. The strings themselves are compared, not the
25901 c_str_view (const char *cstr)
25905 bool operator== (const c_str_view &other) const
25907 return strcmp (m_cstr, other.m_cstr) == 0;
25910 /* Return the underlying C string. Note, the returned string is
25911 only a reference with lifetime of this object. */
25912 const char *c_str () const
25918 friend class c_str_view_hasher;
25919 const char *const m_cstr;
25922 /* A std::unordered_map::hasher for c_str_view that uses the right
25923 hash function for strings in a mapped index. */
25924 class c_str_view_hasher
25927 size_t operator () (const c_str_view &x) const
25929 return mapped_index_string_hash (INT_MAX, x.m_cstr);
25933 /* A std::unordered_map::hasher for std::vector<>. */
25934 template<typename T>
25935 class vector_hasher
25938 size_t operator () (const std::vector<T> &key) const
25940 return iterative_hash (key.data (),
25941 sizeof (key.front ()) * key.size (), 0);
25945 /* Write the mapped hash table SYMTAB to the data buffer OUTPUT, with
25946 constant pool entries going into the data buffer CPOOL. */
25949 write_hash_table (mapped_symtab *symtab, data_buf &output, data_buf &cpool)
25952 /* Elements are sorted vectors of the indices of all the CUs that
25953 hold an object of this name. */
25954 std::unordered_map<std::vector<offset_type>, offset_type,
25955 vector_hasher<offset_type>>
25958 /* We add all the index vectors to the constant pool first, to
25959 ensure alignment is ok. */
25960 for (symtab_index_entry &entry : symtab->data)
25962 if (entry.name == NULL)
25964 gdb_assert (entry.index_offset == 0);
25966 /* Finding before inserting is faster than always trying to
25967 insert, because inserting always allocates a node, does the
25968 lookup, and then destroys the new node if another node
25969 already had the same key. C++17 try_emplace will avoid
25972 = symbol_hash_table.find (entry.cu_indices);
25973 if (found != symbol_hash_table.end ())
25975 entry.index_offset = found->second;
25979 symbol_hash_table.emplace (entry.cu_indices, cpool.size ());
25980 entry.index_offset = cpool.size ();
25981 cpool.append_data (MAYBE_SWAP (entry.cu_indices.size ()));
25982 for (const auto index : entry.cu_indices)
25983 cpool.append_data (MAYBE_SWAP (index));
25987 /* Now write out the hash table. */
25988 std::unordered_map<c_str_view, offset_type, c_str_view_hasher> str_table;
25989 for (const auto &entry : symtab->data)
25991 offset_type str_off, vec_off;
25993 if (entry.name != NULL)
25995 const auto insertpair = str_table.emplace (entry.name, cpool.size ());
25996 if (insertpair.second)
25997 cpool.append_cstr0 (entry.name);
25998 str_off = insertpair.first->second;
25999 vec_off = entry.index_offset;
26003 /* While 0 is a valid constant pool index, it is not valid
26004 to have 0 for both offsets. */
26009 output.append_data (MAYBE_SWAP (str_off));
26010 output.append_data (MAYBE_SWAP (vec_off));
26014 typedef std::unordered_map<partial_symtab *, unsigned int> psym_index_map;
26016 /* Helper struct for building the address table. */
26017 struct addrmap_index_data
26019 addrmap_index_data (data_buf &addr_vec_, psym_index_map &cu_index_htab_)
26020 : addr_vec (addr_vec_), cu_index_htab (cu_index_htab_)
26023 struct objfile *objfile;
26024 data_buf &addr_vec;
26025 psym_index_map &cu_index_htab;
26027 /* Non-zero if the previous_* fields are valid.
26028 We can't write an entry until we see the next entry (since it is only then
26029 that we know the end of the entry). */
26030 int previous_valid;
26031 /* Index of the CU in the table of all CUs in the index file. */
26032 unsigned int previous_cu_index;
26033 /* Start address of the CU. */
26034 CORE_ADDR previous_cu_start;
26037 /* Write an address entry to ADDR_VEC. */
26040 add_address_entry (struct objfile *objfile, data_buf &addr_vec,
26041 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
26043 CORE_ADDR baseaddr;
26045 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
26047 addr_vec.append_uint (8, BFD_ENDIAN_LITTLE, start - baseaddr);
26048 addr_vec.append_uint (8, BFD_ENDIAN_LITTLE, end - baseaddr);
26049 addr_vec.append_data (MAYBE_SWAP (cu_index));
26052 /* Worker function for traversing an addrmap to build the address table. */
26055 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
26057 struct addrmap_index_data *data = (struct addrmap_index_data *) datap;
26058 struct partial_symtab *pst = (struct partial_symtab *) obj;
26060 if (data->previous_valid)
26061 add_address_entry (data->objfile, data->addr_vec,
26062 data->previous_cu_start, start_addr,
26063 data->previous_cu_index);
26065 data->previous_cu_start = start_addr;
26068 const auto it = data->cu_index_htab.find (pst);
26069 gdb_assert (it != data->cu_index_htab.cend ());
26070 data->previous_cu_index = it->second;
26071 data->previous_valid = 1;
26074 data->previous_valid = 0;
26079 /* Write OBJFILE's address map to ADDR_VEC.
26080 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
26081 in the index file. */
26084 write_address_map (struct objfile *objfile, data_buf &addr_vec,
26085 psym_index_map &cu_index_htab)
26087 struct addrmap_index_data addrmap_index_data (addr_vec, cu_index_htab);
26089 /* When writing the address table, we have to cope with the fact that
26090 the addrmap iterator only provides the start of a region; we have to
26091 wait until the next invocation to get the start of the next region. */
26093 addrmap_index_data.objfile = objfile;
26094 addrmap_index_data.previous_valid = 0;
26096 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
26097 &addrmap_index_data);
26099 /* It's highly unlikely the last entry (end address = 0xff...ff)
26100 is valid, but we should still handle it.
26101 The end address is recorded as the start of the next region, but that
26102 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
26104 if (addrmap_index_data.previous_valid)
26105 add_address_entry (objfile, addr_vec,
26106 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
26107 addrmap_index_data.previous_cu_index);
26110 /* Return the symbol kind of PSYM. */
26112 static gdb_index_symbol_kind
26113 symbol_kind (struct partial_symbol *psym)
26115 domain_enum domain = PSYMBOL_DOMAIN (psym);
26116 enum address_class aclass = PSYMBOL_CLASS (psym);
26124 return GDB_INDEX_SYMBOL_KIND_FUNCTION;
26126 return GDB_INDEX_SYMBOL_KIND_TYPE;
26128 case LOC_CONST_BYTES:
26129 case LOC_OPTIMIZED_OUT:
26131 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
26133 /* Note: It's currently impossible to recognize psyms as enum values
26134 short of reading the type info. For now punt. */
26135 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
26137 /* There are other LOC_FOO values that one might want to classify
26138 as variables, but dwarf2read.c doesn't currently use them. */
26139 return GDB_INDEX_SYMBOL_KIND_OTHER;
26141 case STRUCT_DOMAIN:
26142 return GDB_INDEX_SYMBOL_KIND_TYPE;
26144 return GDB_INDEX_SYMBOL_KIND_OTHER;
26148 /* Add a list of partial symbols to SYMTAB. */
26151 write_psymbols (struct mapped_symtab *symtab,
26152 std::unordered_set<partial_symbol *> &psyms_seen,
26153 struct partial_symbol **psymp,
26155 offset_type cu_index,
26158 for (; count-- > 0; ++psymp)
26160 struct partial_symbol *psym = *psymp;
26162 if (SYMBOL_LANGUAGE (psym) == language_ada)
26163 error (_("Ada is not currently supported by the index"));
26165 /* Only add a given psymbol once. */
26166 if (psyms_seen.insert (psym).second)
26168 gdb_index_symbol_kind kind = symbol_kind (psym);
26170 add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
26171 is_static, kind, cu_index);
26176 /* A helper struct used when iterating over debug_types. */
26177 struct signatured_type_index_data
26179 signatured_type_index_data (data_buf &types_list_,
26180 std::unordered_set<partial_symbol *> &psyms_seen_)
26181 : types_list (types_list_), psyms_seen (psyms_seen_)
26184 struct objfile *objfile;
26185 struct mapped_symtab *symtab;
26186 data_buf &types_list;
26187 std::unordered_set<partial_symbol *> &psyms_seen;
26191 /* A helper function that writes a single signatured_type to an
26195 write_one_signatured_type (void **slot, void *d)
26197 struct signatured_type_index_data *info
26198 = (struct signatured_type_index_data *) d;
26199 struct signatured_type *entry = (struct signatured_type *) *slot;
26200 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
26202 write_psymbols (info->symtab,
26204 &info->objfile->global_psymbols[psymtab->globals_offset],
26205 psymtab->n_global_syms, info->cu_index,
26207 write_psymbols (info->symtab,
26209 &info->objfile->static_psymbols[psymtab->statics_offset],
26210 psymtab->n_static_syms, info->cu_index,
26213 info->types_list.append_uint (8, BFD_ENDIAN_LITTLE,
26214 to_underlying (entry->per_cu.sect_off));
26215 info->types_list.append_uint (8, BFD_ENDIAN_LITTLE,
26216 to_underlying (entry->type_offset_in_tu));
26217 info->types_list.append_uint (8, BFD_ENDIAN_LITTLE, entry->signature);
26224 /* Recurse into all "included" dependencies and count their symbols as
26225 if they appeared in this psymtab. */
26228 recursively_count_psymbols (struct partial_symtab *psymtab,
26229 size_t &psyms_seen)
26231 for (int i = 0; i < psymtab->number_of_dependencies; ++i)
26232 if (psymtab->dependencies[i]->user != NULL)
26233 recursively_count_psymbols (psymtab->dependencies[i],
26236 psyms_seen += psymtab->n_global_syms;
26237 psyms_seen += psymtab->n_static_syms;
26240 /* Recurse into all "included" dependencies and write their symbols as
26241 if they appeared in this psymtab. */
26244 recursively_write_psymbols (struct objfile *objfile,
26245 struct partial_symtab *psymtab,
26246 struct mapped_symtab *symtab,
26247 std::unordered_set<partial_symbol *> &psyms_seen,
26248 offset_type cu_index)
26252 for (i = 0; i < psymtab->number_of_dependencies; ++i)
26253 if (psymtab->dependencies[i]->user != NULL)
26254 recursively_write_psymbols (objfile, psymtab->dependencies[i],
26255 symtab, psyms_seen, cu_index);
26257 write_psymbols (symtab,
26259 &objfile->global_psymbols[psymtab->globals_offset],
26260 psymtab->n_global_syms, cu_index,
26262 write_psymbols (symtab,
26264 &objfile->static_psymbols[psymtab->statics_offset],
26265 psymtab->n_static_syms, cu_index,
26269 /* DWARF-5 .debug_names builder. */
26273 debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile, bool is_dwarf64,
26274 bfd_endian dwarf5_byte_order)
26275 : m_dwarf5_byte_order (dwarf5_byte_order),
26276 m_dwarf32 (dwarf5_byte_order),
26277 m_dwarf64 (dwarf5_byte_order),
26278 m_dwarf (is_dwarf64
26279 ? static_cast<dwarf &> (m_dwarf64)
26280 : static_cast<dwarf &> (m_dwarf32)),
26281 m_name_table_string_offs (m_dwarf.name_table_string_offs),
26282 m_name_table_entry_offs (m_dwarf.name_table_entry_offs),
26283 m_debugstrlookup (dwarf2_per_objfile)
26286 int dwarf5_offset_size () const
26288 const bool dwarf5_is_dwarf64 = &m_dwarf == &m_dwarf64;
26289 return dwarf5_is_dwarf64 ? 8 : 4;
26292 /* Is this symbol from DW_TAG_compile_unit or DW_TAG_type_unit? */
26293 enum class unit_kind { cu, tu };
26295 /* Insert one symbol. */
26296 void insert (const partial_symbol *psym, int cu_index, bool is_static,
26299 const int dwarf_tag = psymbol_tag (psym);
26300 if (dwarf_tag == 0)
26302 const char *const name = SYMBOL_SEARCH_NAME (psym);
26303 const auto insertpair
26304 = m_name_to_value_set.emplace (c_str_view (name),
26305 std::set<symbol_value> ());
26306 std::set<symbol_value> &value_set = insertpair.first->second;
26307 value_set.emplace (symbol_value (dwarf_tag, cu_index, is_static, kind));
26310 /* Build all the tables. All symbols must be already inserted.
26311 This function does not call file_write, caller has to do it
26315 /* Verify the build method has not be called twice. */
26316 gdb_assert (m_abbrev_table.empty ());
26317 const size_t name_count = m_name_to_value_set.size ();
26318 m_bucket_table.resize
26319 (std::pow (2, std::ceil (std::log2 (name_count * 4 / 3))));
26320 m_hash_table.reserve (name_count);
26321 m_name_table_string_offs.reserve (name_count);
26322 m_name_table_entry_offs.reserve (name_count);
26324 /* Map each hash of symbol to its name and value. */
26325 struct hash_it_pair
26328 decltype (m_name_to_value_set)::const_iterator it;
26330 std::vector<std::forward_list<hash_it_pair>> bucket_hash;
26331 bucket_hash.resize (m_bucket_table.size ());
26332 for (decltype (m_name_to_value_set)::const_iterator it
26333 = m_name_to_value_set.cbegin ();
26334 it != m_name_to_value_set.cend ();
26337 const char *const name = it->first.c_str ();
26338 const uint32_t hash = dwarf5_djb_hash (name);
26339 hash_it_pair hashitpair;
26340 hashitpair.hash = hash;
26341 hashitpair.it = it;
26342 auto &slot = bucket_hash[hash % bucket_hash.size()];
26343 slot.push_front (std::move (hashitpair));
26345 for (size_t bucket_ix = 0; bucket_ix < bucket_hash.size (); ++bucket_ix)
26347 const std::forward_list<hash_it_pair> &hashitlist
26348 = bucket_hash[bucket_ix];
26349 if (hashitlist.empty ())
26351 uint32_t &bucket_slot = m_bucket_table[bucket_ix];
26352 /* The hashes array is indexed starting at 1. */
26353 store_unsigned_integer (reinterpret_cast<gdb_byte *> (&bucket_slot),
26354 sizeof (bucket_slot), m_dwarf5_byte_order,
26355 m_hash_table.size () + 1);
26356 for (const hash_it_pair &hashitpair : hashitlist)
26358 m_hash_table.push_back (0);
26359 store_unsigned_integer (reinterpret_cast<gdb_byte *>
26360 (&m_hash_table.back ()),
26361 sizeof (m_hash_table.back ()),
26362 m_dwarf5_byte_order, hashitpair.hash);
26363 const c_str_view &name = hashitpair.it->first;
26364 const std::set<symbol_value> &value_set = hashitpair.it->second;
26365 m_name_table_string_offs.push_back_reorder
26366 (m_debugstrlookup.lookup (name.c_str ()));
26367 m_name_table_entry_offs.push_back_reorder (m_entry_pool.size ());
26368 gdb_assert (!value_set.empty ());
26369 for (const symbol_value &value : value_set)
26371 int &idx = m_indexkey_to_idx[index_key (value.dwarf_tag,
26376 idx = m_idx_next++;
26377 m_abbrev_table.append_unsigned_leb128 (idx);
26378 m_abbrev_table.append_unsigned_leb128 (value.dwarf_tag);
26379 m_abbrev_table.append_unsigned_leb128
26380 (value.kind == unit_kind::cu ? DW_IDX_compile_unit
26381 : DW_IDX_type_unit);
26382 m_abbrev_table.append_unsigned_leb128 (DW_FORM_udata);
26383 m_abbrev_table.append_unsigned_leb128 (value.is_static
26384 ? DW_IDX_GNU_internal
26385 : DW_IDX_GNU_external);
26386 m_abbrev_table.append_unsigned_leb128 (DW_FORM_flag_present);
26388 /* Terminate attributes list. */
26389 m_abbrev_table.append_unsigned_leb128 (0);
26390 m_abbrev_table.append_unsigned_leb128 (0);
26393 m_entry_pool.append_unsigned_leb128 (idx);
26394 m_entry_pool.append_unsigned_leb128 (value.cu_index);
26397 /* Terminate the list of CUs. */
26398 m_entry_pool.append_unsigned_leb128 (0);
26401 gdb_assert (m_hash_table.size () == name_count);
26403 /* Terminate tags list. */
26404 m_abbrev_table.append_unsigned_leb128 (0);
26407 /* Return .debug_names bucket count. This must be called only after
26408 calling the build method. */
26409 uint32_t bucket_count () const
26411 /* Verify the build method has been already called. */
26412 gdb_assert (!m_abbrev_table.empty ());
26413 const uint32_t retval = m_bucket_table.size ();
26415 /* Check for overflow. */
26416 gdb_assert (retval == m_bucket_table.size ());
26420 /* Return .debug_names names count. This must be called only after
26421 calling the build method. */
26422 uint32_t name_count () const
26424 /* Verify the build method has been already called. */
26425 gdb_assert (!m_abbrev_table.empty ());
26426 const uint32_t retval = m_hash_table.size ();
26428 /* Check for overflow. */
26429 gdb_assert (retval == m_hash_table.size ());
26433 /* Return number of bytes of .debug_names abbreviation table. This
26434 must be called only after calling the build method. */
26435 uint32_t abbrev_table_bytes () const
26437 gdb_assert (!m_abbrev_table.empty ());
26438 return m_abbrev_table.size ();
26441 /* Recurse into all "included" dependencies and store their symbols
26442 as if they appeared in this psymtab. */
26443 void recursively_write_psymbols
26444 (struct objfile *objfile,
26445 struct partial_symtab *psymtab,
26446 std::unordered_set<partial_symbol *> &psyms_seen,
26449 for (int i = 0; i < psymtab->number_of_dependencies; ++i)
26450 if (psymtab->dependencies[i]->user != NULL)
26451 recursively_write_psymbols (objfile, psymtab->dependencies[i],
26452 psyms_seen, cu_index);
26454 write_psymbols (psyms_seen,
26455 &objfile->global_psymbols[psymtab->globals_offset],
26456 psymtab->n_global_syms, cu_index, false, unit_kind::cu);
26457 write_psymbols (psyms_seen,
26458 &objfile->static_psymbols[psymtab->statics_offset],
26459 psymtab->n_static_syms, cu_index, true, unit_kind::cu);
26462 /* Return number of bytes the .debug_names section will have. This
26463 must be called only after calling the build method. */
26464 size_t bytes () const
26466 /* Verify the build method has been already called. */
26467 gdb_assert (!m_abbrev_table.empty ());
26468 size_t expected_bytes = 0;
26469 expected_bytes += m_bucket_table.size () * sizeof (m_bucket_table[0]);
26470 expected_bytes += m_hash_table.size () * sizeof (m_hash_table[0]);
26471 expected_bytes += m_name_table_string_offs.bytes ();
26472 expected_bytes += m_name_table_entry_offs.bytes ();
26473 expected_bytes += m_abbrev_table.size ();
26474 expected_bytes += m_entry_pool.size ();
26475 return expected_bytes;
26478 /* Write .debug_names to FILE_NAMES and .debug_str addition to
26479 FILE_STR. This must be called only after calling the build
26481 void file_write (FILE *file_names, FILE *file_str) const
26483 /* Verify the build method has been already called. */
26484 gdb_assert (!m_abbrev_table.empty ());
26485 ::file_write (file_names, m_bucket_table);
26486 ::file_write (file_names, m_hash_table);
26487 m_name_table_string_offs.file_write (file_names);
26488 m_name_table_entry_offs.file_write (file_names);
26489 m_abbrev_table.file_write (file_names);
26490 m_entry_pool.file_write (file_names);
26491 m_debugstrlookup.file_write (file_str);
26494 /* A helper user data for write_one_signatured_type. */
26495 class write_one_signatured_type_data
26498 write_one_signatured_type_data (debug_names &nametable_,
26499 signatured_type_index_data &&info_)
26500 : nametable (nametable_), info (std::move (info_))
26502 debug_names &nametable;
26503 struct signatured_type_index_data info;
26506 /* A helper function to pass write_one_signatured_type to
26507 htab_traverse_noresize. */
26509 write_one_signatured_type (void **slot, void *d)
26511 write_one_signatured_type_data *data = (write_one_signatured_type_data *) d;
26512 struct signatured_type_index_data *info = &data->info;
26513 struct signatured_type *entry = (struct signatured_type *) *slot;
26515 data->nametable.write_one_signatured_type (entry, info);
26522 /* Storage for symbol names mapping them to their .debug_str section
26524 class debug_str_lookup
26528 /* Object costructor to be called for current DWARF2_PER_OBJFILE.
26529 All .debug_str section strings are automatically stored. */
26530 debug_str_lookup (struct dwarf2_per_objfile *dwarf2_per_objfile)
26531 : m_abfd (dwarf2_per_objfile->objfile->obfd),
26532 m_dwarf2_per_objfile (dwarf2_per_objfile)
26534 dwarf2_read_section (dwarf2_per_objfile->objfile,
26535 &dwarf2_per_objfile->str);
26536 if (dwarf2_per_objfile->str.buffer == NULL)
26538 for (const gdb_byte *data = dwarf2_per_objfile->str.buffer;
26539 data < (dwarf2_per_objfile->str.buffer
26540 + dwarf2_per_objfile->str.size);)
26542 const char *const s = reinterpret_cast<const char *> (data);
26543 const auto insertpair
26544 = m_str_table.emplace (c_str_view (s),
26545 data - dwarf2_per_objfile->str.buffer);
26546 if (!insertpair.second)
26547 complaint (&symfile_complaints,
26548 _("Duplicate string \"%s\" in "
26549 ".debug_str section [in module %s]"),
26550 s, bfd_get_filename (m_abfd));
26551 data += strlen (s) + 1;
26555 /* Return offset of symbol name S in the .debug_str section. Add
26556 such symbol to the section's end if it does not exist there
26558 size_t lookup (const char *s)
26560 const auto it = m_str_table.find (c_str_view (s));
26561 if (it != m_str_table.end ())
26563 const size_t offset = (m_dwarf2_per_objfile->str.size
26564 + m_str_add_buf.size ());
26565 m_str_table.emplace (c_str_view (s), offset);
26566 m_str_add_buf.append_cstr0 (s);
26570 /* Append the end of the .debug_str section to FILE. */
26571 void file_write (FILE *file) const
26573 m_str_add_buf.file_write (file);
26577 std::unordered_map<c_str_view, size_t, c_str_view_hasher> m_str_table;
26579 struct dwarf2_per_objfile *m_dwarf2_per_objfile;
26581 /* Data to add at the end of .debug_str for new needed symbol names. */
26582 data_buf m_str_add_buf;
26585 /* Container to map used DWARF tags to their .debug_names abbreviation
26590 index_key (int dwarf_tag_, bool is_static_, unit_kind kind_)
26591 : dwarf_tag (dwarf_tag_), is_static (is_static_), kind (kind_)
26596 operator== (const index_key &other) const
26598 return (dwarf_tag == other.dwarf_tag && is_static == other.is_static
26599 && kind == other.kind);
26602 const int dwarf_tag;
26603 const bool is_static;
26604 const unit_kind kind;
26607 /* Provide std::unordered_map::hasher for index_key. */
26608 class index_key_hasher
26612 operator () (const index_key &key) const
26614 return (std::hash<int>() (key.dwarf_tag) << 1) | key.is_static;
26618 /* Parameters of one symbol entry. */
26622 const int dwarf_tag, cu_index;
26623 const bool is_static;
26624 const unit_kind kind;
26626 symbol_value (int dwarf_tag_, int cu_index_, bool is_static_,
26628 : dwarf_tag (dwarf_tag_), cu_index (cu_index_), is_static (is_static_),
26633 operator< (const symbol_value &other) const
26653 /* Abstract base class to unify DWARF-32 and DWARF-64 name table
26658 const bfd_endian dwarf5_byte_order;
26660 explicit offset_vec (bfd_endian dwarf5_byte_order_)
26661 : dwarf5_byte_order (dwarf5_byte_order_)
26664 /* Call std::vector::reserve for NELEM elements. */
26665 virtual void reserve (size_t nelem) = 0;
26667 /* Call std::vector::push_back with store_unsigned_integer byte
26668 reordering for ELEM. */
26669 virtual void push_back_reorder (size_t elem) = 0;
26671 /* Return expected output size in bytes. */
26672 virtual size_t bytes () const = 0;
26674 /* Write name table to FILE. */
26675 virtual void file_write (FILE *file) const = 0;
26678 /* Template to unify DWARF-32 and DWARF-64 output. */
26679 template<typename OffsetSize>
26680 class offset_vec_tmpl : public offset_vec
26683 explicit offset_vec_tmpl (bfd_endian dwarf5_byte_order_)
26684 : offset_vec (dwarf5_byte_order_)
26687 /* Implement offset_vec::reserve. */
26688 void reserve (size_t nelem) override
26690 m_vec.reserve (nelem);
26693 /* Implement offset_vec::push_back_reorder. */
26694 void push_back_reorder (size_t elem) override
26696 m_vec.push_back (elem);
26697 /* Check for overflow. */
26698 gdb_assert (m_vec.back () == elem);
26699 store_unsigned_integer (reinterpret_cast<gdb_byte *> (&m_vec.back ()),
26700 sizeof (m_vec.back ()), dwarf5_byte_order, elem);
26703 /* Implement offset_vec::bytes. */
26704 size_t bytes () const override
26706 return m_vec.size () * sizeof (m_vec[0]);
26709 /* Implement offset_vec::file_write. */
26710 void file_write (FILE *file) const override
26712 ::file_write (file, m_vec);
26716 std::vector<OffsetSize> m_vec;
26719 /* Base class to unify DWARF-32 and DWARF-64 .debug_names output
26720 respecting name table width. */
26724 offset_vec &name_table_string_offs, &name_table_entry_offs;
26726 dwarf (offset_vec &name_table_string_offs_,
26727 offset_vec &name_table_entry_offs_)
26728 : name_table_string_offs (name_table_string_offs_),
26729 name_table_entry_offs (name_table_entry_offs_)
26734 /* Template to unify DWARF-32 and DWARF-64 .debug_names output
26735 respecting name table width. */
26736 template<typename OffsetSize>
26737 class dwarf_tmpl : public dwarf
26740 explicit dwarf_tmpl (bfd_endian dwarf5_byte_order_)
26741 : dwarf (m_name_table_string_offs, m_name_table_entry_offs),
26742 m_name_table_string_offs (dwarf5_byte_order_),
26743 m_name_table_entry_offs (dwarf5_byte_order_)
26747 offset_vec_tmpl<OffsetSize> m_name_table_string_offs;
26748 offset_vec_tmpl<OffsetSize> m_name_table_entry_offs;
26751 /* Try to reconstruct original DWARF tag for given partial_symbol.
26752 This function is not DWARF-5 compliant but it is sufficient for
26753 GDB as a DWARF-5 index consumer. */
26754 static int psymbol_tag (const struct partial_symbol *psym)
26756 domain_enum domain = PSYMBOL_DOMAIN (psym);
26757 enum address_class aclass = PSYMBOL_CLASS (psym);
26765 return DW_TAG_subprogram;
26767 return DW_TAG_typedef;
26769 case LOC_CONST_BYTES:
26770 case LOC_OPTIMIZED_OUT:
26772 return DW_TAG_variable;
26774 /* Note: It's currently impossible to recognize psyms as enum values
26775 short of reading the type info. For now punt. */
26776 return DW_TAG_variable;
26778 /* There are other LOC_FOO values that one might want to classify
26779 as variables, but dwarf2read.c doesn't currently use them. */
26780 return DW_TAG_variable;
26782 case STRUCT_DOMAIN:
26783 return DW_TAG_structure_type;
26789 /* Call insert for all partial symbols and mark them in PSYMS_SEEN. */
26790 void write_psymbols (std::unordered_set<partial_symbol *> &psyms_seen,
26791 struct partial_symbol **psymp, int count, int cu_index,
26792 bool is_static, unit_kind kind)
26794 for (; count-- > 0; ++psymp)
26796 struct partial_symbol *psym = *psymp;
26798 if (SYMBOL_LANGUAGE (psym) == language_ada)
26799 error (_("Ada is not currently supported by the index"));
26801 /* Only add a given psymbol once. */
26802 if (psyms_seen.insert (psym).second)
26803 insert (psym, cu_index, is_static, kind);
26807 /* A helper function that writes a single signatured_type
26808 to a debug_names. */
26810 write_one_signatured_type (struct signatured_type *entry,
26811 struct signatured_type_index_data *info)
26813 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
26815 write_psymbols (info->psyms_seen,
26816 &info->objfile->global_psymbols[psymtab->globals_offset],
26817 psymtab->n_global_syms, info->cu_index, false,
26819 write_psymbols (info->psyms_seen,
26820 &info->objfile->static_psymbols[psymtab->statics_offset],
26821 psymtab->n_static_syms, info->cu_index, true,
26824 info->types_list.append_uint (dwarf5_offset_size (), m_dwarf5_byte_order,
26825 to_underlying (entry->per_cu.sect_off));
26830 /* Store value of each symbol. */
26831 std::unordered_map<c_str_view, std::set<symbol_value>, c_str_view_hasher>
26832 m_name_to_value_set;
26834 /* Tables of DWARF-5 .debug_names. They are in object file byte
26836 std::vector<uint32_t> m_bucket_table;
26837 std::vector<uint32_t> m_hash_table;
26839 const bfd_endian m_dwarf5_byte_order;
26840 dwarf_tmpl<uint32_t> m_dwarf32;
26841 dwarf_tmpl<uint64_t> m_dwarf64;
26843 offset_vec &m_name_table_string_offs, &m_name_table_entry_offs;
26844 debug_str_lookup m_debugstrlookup;
26846 /* Map each used .debug_names abbreviation tag parameter to its
26848 std::unordered_map<index_key, int, index_key_hasher> m_indexkey_to_idx;
26850 /* Next unused .debug_names abbreviation tag for
26851 m_indexkey_to_idx. */
26852 int m_idx_next = 1;
26854 /* .debug_names abbreviation table. */
26855 data_buf m_abbrev_table;
26857 /* .debug_names entry pool. */
26858 data_buf m_entry_pool;
26861 /* Return iff any of the needed offsets does not fit into 32-bit
26862 .debug_names section. */
26865 check_dwarf64_offsets (struct dwarf2_per_objfile *dwarf2_per_objfile)
26867 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
26869 const dwarf2_per_cu_data &per_cu = *dwarf2_per_objfile->all_comp_units[i];
26871 if (to_underlying (per_cu.sect_off) >= (static_cast<uint64_t> (1) << 32))
26874 for (int i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
26876 const signatured_type &sigtype = *dwarf2_per_objfile->all_type_units[i];
26877 const dwarf2_per_cu_data &per_cu = sigtype.per_cu;
26879 if (to_underlying (per_cu.sect_off) >= (static_cast<uint64_t> (1) << 32))
26885 /* The psyms_seen set is potentially going to be largish (~40k
26886 elements when indexing a -g3 build of GDB itself). Estimate the
26887 number of elements in order to avoid too many rehashes, which
26888 require rebuilding buckets and thus many trips to
26892 psyms_seen_size (struct dwarf2_per_objfile *dwarf2_per_objfile)
26894 size_t psyms_count = 0;
26895 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
26897 struct dwarf2_per_cu_data *per_cu
26898 = dwarf2_per_objfile->all_comp_units[i];
26899 struct partial_symtab *psymtab = per_cu->v.psymtab;
26901 if (psymtab != NULL && psymtab->user == NULL)
26902 recursively_count_psymbols (psymtab, psyms_count);
26904 /* Generating an index for gdb itself shows a ratio of
26905 TOTAL_SEEN_SYMS/UNIQUE_SYMS or ~5. 4 seems like a good bet. */
26906 return psyms_count / 4;
26909 /* Write new .gdb_index section for OBJFILE into OUT_FILE.
26910 Return how many bytes were expected to be written into OUT_FILE. */
26913 write_gdbindex (struct dwarf2_per_objfile *dwarf2_per_objfile, FILE *out_file)
26915 struct objfile *objfile = dwarf2_per_objfile->objfile;
26916 mapped_symtab symtab;
26919 /* While we're scanning CU's create a table that maps a psymtab pointer
26920 (which is what addrmap records) to its index (which is what is recorded
26921 in the index file). This will later be needed to write the address
26923 psym_index_map cu_index_htab;
26924 cu_index_htab.reserve (dwarf2_per_objfile->n_comp_units);
26926 /* The CU list is already sorted, so we don't need to do additional
26927 work here. Also, the debug_types entries do not appear in
26928 all_comp_units, but only in their own hash table. */
26930 std::unordered_set<partial_symbol *> psyms_seen
26931 (psyms_seen_size (dwarf2_per_objfile));
26932 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
26934 struct dwarf2_per_cu_data *per_cu
26935 = dwarf2_per_objfile->all_comp_units[i];
26936 struct partial_symtab *psymtab = per_cu->v.psymtab;
26938 /* CU of a shared file from 'dwz -m' may be unused by this main file.
26939 It may be referenced from a local scope but in such case it does not
26940 need to be present in .gdb_index. */
26941 if (psymtab == NULL)
26944 if (psymtab->user == NULL)
26945 recursively_write_psymbols (objfile, psymtab, &symtab,
26948 const auto insertpair = cu_index_htab.emplace (psymtab, i);
26949 gdb_assert (insertpair.second);
26951 cu_list.append_uint (8, BFD_ENDIAN_LITTLE,
26952 to_underlying (per_cu->sect_off));
26953 cu_list.append_uint (8, BFD_ENDIAN_LITTLE, per_cu->length);
26956 /* Dump the address map. */
26958 write_address_map (objfile, addr_vec, cu_index_htab);
26960 /* Write out the .debug_type entries, if any. */
26961 data_buf types_cu_list;
26962 if (dwarf2_per_objfile->signatured_types)
26964 signatured_type_index_data sig_data (types_cu_list,
26967 sig_data.objfile = objfile;
26968 sig_data.symtab = &symtab;
26969 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
26970 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
26971 write_one_signatured_type, &sig_data);
26974 /* Now that we've processed all symbols we can shrink their cu_indices
26976 uniquify_cu_indices (&symtab);
26978 data_buf symtab_vec, constant_pool;
26979 write_hash_table (&symtab, symtab_vec, constant_pool);
26982 const offset_type size_of_contents = 6 * sizeof (offset_type);
26983 offset_type total_len = size_of_contents;
26985 /* The version number. */
26986 contents.append_data (MAYBE_SWAP (8));
26988 /* The offset of the CU list from the start of the file. */
26989 contents.append_data (MAYBE_SWAP (total_len));
26990 total_len += cu_list.size ();
26992 /* The offset of the types CU list from the start of the file. */
26993 contents.append_data (MAYBE_SWAP (total_len));
26994 total_len += types_cu_list.size ();
26996 /* The offset of the address table from the start of the file. */
26997 contents.append_data (MAYBE_SWAP (total_len));
26998 total_len += addr_vec.size ();
27000 /* The offset of the symbol table from the start of the file. */
27001 contents.append_data (MAYBE_SWAP (total_len));
27002 total_len += symtab_vec.size ();
27004 /* The offset of the constant pool from the start of the file. */
27005 contents.append_data (MAYBE_SWAP (total_len));
27006 total_len += constant_pool.size ();
27008 gdb_assert (contents.size () == size_of_contents);
27010 contents.file_write (out_file);
27011 cu_list.file_write (out_file);
27012 types_cu_list.file_write (out_file);
27013 addr_vec.file_write (out_file);
27014 symtab_vec.file_write (out_file);
27015 constant_pool.file_write (out_file);
27020 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
27021 static const gdb_byte dwarf5_gdb_augmentation[] = { 'G', 'D', 'B', 0 };
27023 /* Write a new .debug_names section for OBJFILE into OUT_FILE, write
27024 needed addition to .debug_str section to OUT_FILE_STR. Return how
27025 many bytes were expected to be written into OUT_FILE. */
27028 write_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
27029 FILE *out_file, FILE *out_file_str)
27031 const bool dwarf5_is_dwarf64 = check_dwarf64_offsets (dwarf2_per_objfile);
27032 struct objfile *objfile = dwarf2_per_objfile->objfile;
27033 const enum bfd_endian dwarf5_byte_order
27034 = gdbarch_byte_order (get_objfile_arch (objfile));
27036 /* The CU list is already sorted, so we don't need to do additional
27037 work here. Also, the debug_types entries do not appear in
27038 all_comp_units, but only in their own hash table. */
27040 debug_names nametable (dwarf2_per_objfile, dwarf5_is_dwarf64,
27041 dwarf5_byte_order);
27042 std::unordered_set<partial_symbol *>
27043 psyms_seen (psyms_seen_size (dwarf2_per_objfile));
27044 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
27046 const dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->all_comp_units[i];
27047 partial_symtab *psymtab = per_cu->v.psymtab;
27049 /* CU of a shared file from 'dwz -m' may be unused by this main
27050 file. It may be referenced from a local scope but in such
27051 case it does not need to be present in .debug_names. */
27052 if (psymtab == NULL)
27055 if (psymtab->user == NULL)
27056 nametable.recursively_write_psymbols (objfile, psymtab, psyms_seen, i);
27058 cu_list.append_uint (nametable.dwarf5_offset_size (), dwarf5_byte_order,
27059 to_underlying (per_cu->sect_off));
27062 /* Write out the .debug_type entries, if any. */
27063 data_buf types_cu_list;
27064 if (dwarf2_per_objfile->signatured_types)
27066 debug_names::write_one_signatured_type_data sig_data (nametable,
27067 signatured_type_index_data (types_cu_list, psyms_seen));
27069 sig_data.info.objfile = objfile;
27070 /* It is used only for gdb_index. */
27071 sig_data.info.symtab = nullptr;
27072 sig_data.info.cu_index = 0;
27073 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
27074 debug_names::write_one_signatured_type,
27078 nametable.build ();
27080 /* No addr_vec - DWARF-5 uses .debug_aranges generated by GCC. */
27082 const offset_type bytes_of_header
27083 = ((dwarf5_is_dwarf64 ? 12 : 4)
27085 + sizeof (dwarf5_gdb_augmentation));
27086 size_t expected_bytes = 0;
27087 expected_bytes += bytes_of_header;
27088 expected_bytes += cu_list.size ();
27089 expected_bytes += types_cu_list.size ();
27090 expected_bytes += nametable.bytes ();
27093 if (!dwarf5_is_dwarf64)
27095 const uint64_t size64 = expected_bytes - 4;
27096 gdb_assert (size64 < 0xfffffff0);
27097 header.append_uint (4, dwarf5_byte_order, size64);
27101 header.append_uint (4, dwarf5_byte_order, 0xffffffff);
27102 header.append_uint (8, dwarf5_byte_order, expected_bytes - 12);
27105 /* The version number. */
27106 header.append_uint (2, dwarf5_byte_order, 5);
27109 header.append_uint (2, dwarf5_byte_order, 0);
27111 /* comp_unit_count - The number of CUs in the CU list. */
27112 header.append_uint (4, dwarf5_byte_order, dwarf2_per_objfile->n_comp_units);
27114 /* local_type_unit_count - The number of TUs in the local TU
27116 header.append_uint (4, dwarf5_byte_order, dwarf2_per_objfile->n_type_units);
27118 /* foreign_type_unit_count - The number of TUs in the foreign TU
27120 header.append_uint (4, dwarf5_byte_order, 0);
27122 /* bucket_count - The number of hash buckets in the hash lookup
27124 header.append_uint (4, dwarf5_byte_order, nametable.bucket_count ());
27126 /* name_count - The number of unique names in the index. */
27127 header.append_uint (4, dwarf5_byte_order, nametable.name_count ());
27129 /* abbrev_table_size - The size in bytes of the abbreviations
27131 header.append_uint (4, dwarf5_byte_order, nametable.abbrev_table_bytes ());
27133 /* augmentation_string_size - The size in bytes of the augmentation
27134 string. This value is rounded up to a multiple of 4. */
27135 static_assert (sizeof (dwarf5_gdb_augmentation) % 4 == 0, "");
27136 header.append_uint (4, dwarf5_byte_order, sizeof (dwarf5_gdb_augmentation));
27137 header.append_data (dwarf5_gdb_augmentation);
27139 gdb_assert (header.size () == bytes_of_header);
27141 header.file_write (out_file);
27142 cu_list.file_write (out_file);
27143 types_cu_list.file_write (out_file);
27144 nametable.file_write (out_file, out_file_str);
27146 return expected_bytes;
27149 /* Assert that FILE's size is EXPECTED_SIZE. Assumes file's seek
27150 position is at the end of the file. */
27153 assert_file_size (FILE *file, const char *filename, size_t expected_size)
27155 const auto file_size = ftell (file);
27156 if (file_size == -1)
27157 error (_("Can't get `%s' size"), filename);
27158 gdb_assert (file_size == expected_size);
27161 /* Create an index file for OBJFILE in the directory DIR. */
27164 write_psymtabs_to_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
27166 dw_index_kind index_kind)
27168 struct objfile *objfile = dwarf2_per_objfile->objfile;
27170 if (dwarf2_per_objfile->using_index)
27171 error (_("Cannot use an index to create the index"));
27173 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
27174 error (_("Cannot make an index when the file has multiple .debug_types sections"));
27176 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
27180 if (stat (objfile_name (objfile), &st) < 0)
27181 perror_with_name (objfile_name (objfile));
27183 std::string filename (std::string (dir) + SLASH_STRING
27184 + lbasename (objfile_name (objfile))
27185 + (index_kind == dw_index_kind::DEBUG_NAMES
27186 ? INDEX5_SUFFIX : INDEX4_SUFFIX));
27188 FILE *out_file = gdb_fopen_cloexec (filename.c_str (), "wb").release ();
27190 error (_("Can't open `%s' for writing"), filename.c_str ());
27192 /* Order matters here; we want FILE to be closed before FILENAME is
27193 unlinked, because on MS-Windows one cannot delete a file that is
27194 still open. (Don't call anything here that might throw until
27195 file_closer is created.) */
27196 gdb::unlinker unlink_file (filename.c_str ());
27197 gdb_file_up close_out_file (out_file);
27199 if (index_kind == dw_index_kind::DEBUG_NAMES)
27201 std::string filename_str (std::string (dir) + SLASH_STRING
27202 + lbasename (objfile_name (objfile))
27203 + DEBUG_STR_SUFFIX);
27205 = gdb_fopen_cloexec (filename_str.c_str (), "wb").release ();
27207 error (_("Can't open `%s' for writing"), filename_str.c_str ());
27208 gdb::unlinker unlink_file_str (filename_str.c_str ());
27209 gdb_file_up close_out_file_str (out_file_str);
27211 const size_t total_len
27212 = write_debug_names (dwarf2_per_objfile, out_file, out_file_str);
27213 assert_file_size (out_file, filename.c_str (), total_len);
27215 /* We want to keep the file .debug_str file too. */
27216 unlink_file_str.keep ();
27220 const size_t total_len
27221 = write_gdbindex (dwarf2_per_objfile, out_file);
27222 assert_file_size (out_file, filename.c_str (), total_len);
27225 /* We want to keep the file. */
27226 unlink_file.keep ();
27229 /* Implementation of the `save gdb-index' command.
27231 Note that the .gdb_index file format used by this command is
27232 documented in the GDB manual. Any changes here must be documented
27236 save_gdb_index_command (const char *arg, int from_tty)
27238 struct objfile *objfile;
27239 const char dwarf5space[] = "-dwarf-5 ";
27240 dw_index_kind index_kind = dw_index_kind::GDB_INDEX;
27245 arg = skip_spaces (arg);
27246 if (strncmp (arg, dwarf5space, strlen (dwarf5space)) == 0)
27248 index_kind = dw_index_kind::DEBUG_NAMES;
27249 arg += strlen (dwarf5space);
27250 arg = skip_spaces (arg);
27254 error (_("usage: save gdb-index [-dwarf-5] DIRECTORY"));
27256 ALL_OBJFILES (objfile)
27260 /* If the objfile does not correspond to an actual file, skip it. */
27261 if (stat (objfile_name (objfile), &st) < 0)
27264 struct dwarf2_per_objfile *dwarf2_per_objfile
27265 = get_dwarf2_per_objfile (objfile);
27267 if (dwarf2_per_objfile != NULL)
27271 write_psymtabs_to_index (dwarf2_per_objfile, arg, index_kind);
27273 CATCH (except, RETURN_MASK_ERROR)
27275 exception_fprintf (gdb_stderr, except,
27276 _("Error while writing index for `%s': "),
27277 objfile_name (objfile));
27287 int dwarf_always_disassemble;
27290 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
27291 struct cmd_list_element *c, const char *value)
27293 fprintf_filtered (file,
27294 _("Whether to always disassemble "
27295 "DWARF expressions is %s.\n"),
27300 show_check_physname (struct ui_file *file, int from_tty,
27301 struct cmd_list_element *c, const char *value)
27303 fprintf_filtered (file,
27304 _("Whether to check \"physname\" is %s.\n"),
27309 _initialize_dwarf2_read (void)
27311 struct cmd_list_element *c;
27313 dwarf2_objfile_data_key
27314 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
27316 add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
27317 Set DWARF specific variables.\n\
27318 Configure DWARF variables such as the cache size"),
27319 &set_dwarf_cmdlist, "maintenance set dwarf ",
27320 0/*allow-unknown*/, &maintenance_set_cmdlist);
27322 add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
27323 Show DWARF specific variables\n\
27324 Show DWARF variables such as the cache size"),
27325 &show_dwarf_cmdlist, "maintenance show dwarf ",
27326 0/*allow-unknown*/, &maintenance_show_cmdlist);
27328 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
27329 &dwarf_max_cache_age, _("\
27330 Set the upper bound on the age of cached DWARF compilation units."), _("\
27331 Show the upper bound on the age of cached DWARF compilation units."), _("\
27332 A higher limit means that cached compilation units will be stored\n\
27333 in memory longer, and more total memory will be used. Zero disables\n\
27334 caching, which can slow down startup."),
27336 show_dwarf_max_cache_age,
27337 &set_dwarf_cmdlist,
27338 &show_dwarf_cmdlist);
27340 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
27341 &dwarf_always_disassemble, _("\
27342 Set whether `info address' always disassembles DWARF expressions."), _("\
27343 Show whether `info address' always disassembles DWARF expressions."), _("\
27344 When enabled, DWARF expressions are always printed in an assembly-like\n\
27345 syntax. When disabled, expressions will be printed in a more\n\
27346 conversational style, when possible."),
27348 show_dwarf_always_disassemble,
27349 &set_dwarf_cmdlist,
27350 &show_dwarf_cmdlist);
27352 add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
27353 Set debugging of the DWARF reader."), _("\
27354 Show debugging of the DWARF reader."), _("\
27355 When enabled (non-zero), debugging messages are printed during DWARF\n\
27356 reading and symtab expansion. A value of 1 (one) provides basic\n\
27357 information. A value greater than 1 provides more verbose information."),
27360 &setdebuglist, &showdebuglist);
27362 add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
27363 Set debugging of the DWARF DIE reader."), _("\
27364 Show debugging of the DWARF DIE reader."), _("\
27365 When enabled (non-zero), DIEs are dumped after they are read in.\n\
27366 The value is the maximum depth to print."),
27369 &setdebuglist, &showdebuglist);
27371 add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
27372 Set debugging of the dwarf line reader."), _("\
27373 Show debugging of the dwarf line reader."), _("\
27374 When enabled (non-zero), line number entries are dumped as they are read in.\n\
27375 A value of 1 (one) provides basic information.\n\
27376 A value greater than 1 provides more verbose information."),
27379 &setdebuglist, &showdebuglist);
27381 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
27382 Set cross-checking of \"physname\" code against demangler."), _("\
27383 Show cross-checking of \"physname\" code against demangler."), _("\
27384 When enabled, GDB's internal \"physname\" code is checked against\n\
27386 NULL, show_check_physname,
27387 &setdebuglist, &showdebuglist);
27389 add_setshow_boolean_cmd ("use-deprecated-index-sections",
27390 no_class, &use_deprecated_index_sections, _("\
27391 Set whether to use deprecated gdb_index sections."), _("\
27392 Show whether to use deprecated gdb_index sections."), _("\
27393 When enabled, deprecated .gdb_index sections are used anyway.\n\
27394 Normally they are ignored either because of a missing feature or\n\
27395 performance issue.\n\
27396 Warning: This option must be enabled before gdb reads the file."),
27399 &setlist, &showlist);
27401 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
27403 Save a gdb-index file.\n\
27404 Usage: save gdb-index [-dwarf-5] DIRECTORY\n\
27406 No options create one file with .gdb-index extension for pre-DWARF-5\n\
27407 compatible .gdb_index section. With -dwarf-5 creates two files with\n\
27408 extension .debug_names and .debug_str for DWARF-5 .debug_names section."),
27410 set_cmd_completer (c, filename_completer);
27412 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
27413 &dwarf2_locexpr_funcs);
27414 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
27415 &dwarf2_loclist_funcs);
27417 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
27418 &dwarf2_block_frame_base_locexpr_funcs);
27419 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
27420 &dwarf2_block_frame_base_loclist_funcs);
27423 selftests::register_test ("dw2_expand_symtabs_matching",
27424 selftests::dw2_expand_symtabs_matching::run_test);