1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2017 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"
74 #include <sys/types.h>
77 typedef struct symbol
*symbolp
;
80 /* When == 1, print basic high level tracing messages.
81 When > 1, be more verbose.
82 This is in contrast to the low level DIE reading of dwarf_die_debug. */
83 static unsigned int dwarf_read_debug
= 0;
85 /* When non-zero, dump DIEs after they are read in. */
86 static unsigned int dwarf_die_debug
= 0;
88 /* When non-zero, dump line number entries as they are read in. */
89 static unsigned int dwarf_line_debug
= 0;
91 /* When non-zero, cross-check physname against demangler. */
92 static int check_physname
= 0;
94 /* When non-zero, do not reject deprecated .gdb_index sections. */
95 static int use_deprecated_index_sections
= 0;
97 static const struct objfile_data
*dwarf2_objfile_data_key
;
99 /* The "aclass" indices for various kinds of computed DWARF symbols. */
101 static int dwarf2_locexpr_index
;
102 static int dwarf2_loclist_index
;
103 static int dwarf2_locexpr_block_index
;
104 static int dwarf2_loclist_block_index
;
106 /* A descriptor for dwarf sections.
108 S.ASECTION, SIZE are typically initialized when the objfile is first
109 scanned. BUFFER, READIN are filled in later when the section is read.
110 If the section contained compressed data then SIZE is updated to record
111 the uncompressed size of the section.
113 DWP file format V2 introduces a wrinkle that is easiest to handle by
114 creating the concept of virtual sections contained within a real section.
115 In DWP V2 the sections of the input DWO files are concatenated together
116 into one section, but section offsets are kept relative to the original
118 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
119 the real section this "virtual" section is contained in, and BUFFER,SIZE
120 describe the virtual section. */
122 struct dwarf2_section_info
126 /* If this is a real section, the bfd section. */
128 /* If this is a virtual section, pointer to the containing ("real")
130 struct dwarf2_section_info
*containing_section
;
132 /* Pointer to section data, only valid if readin. */
133 const gdb_byte
*buffer
;
134 /* The size of the section, real or virtual. */
136 /* If this is a virtual section, the offset in the real section.
137 Only valid if is_virtual. */
138 bfd_size_type virtual_offset
;
139 /* True if we have tried to read this section. */
141 /* True if this is a virtual section, False otherwise.
142 This specifies which of s.section and s.containing_section to use. */
146 typedef struct dwarf2_section_info dwarf2_section_info_def
;
147 DEF_VEC_O (dwarf2_section_info_def
);
149 /* All offsets in the index are of this type. It must be
150 architecture-independent. */
151 typedef uint32_t offset_type
;
153 DEF_VEC_I (offset_type
);
155 /* Ensure only legit values are used. */
156 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
158 gdb_assert ((unsigned int) (value) <= 1); \
159 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
162 /* Ensure only legit values are used. */
163 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
165 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
166 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
167 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
170 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
171 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
173 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
174 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
177 /* A description of the mapped index. The file format is described in
178 a comment by the code that writes the index. */
181 /* Index data format version. */
184 /* The total length of the buffer. */
187 /* A pointer to the address table data. */
188 const gdb_byte
*address_table
;
190 /* Size of the address table data in bytes. */
191 offset_type address_table_size
;
193 /* The symbol table, implemented as a hash table. */
194 const offset_type
*symbol_table
;
196 /* Size in slots, each slot is 2 offset_types. */
197 offset_type symbol_table_slots
;
199 /* A pointer to the constant pool. */
200 const char *constant_pool
;
203 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
204 DEF_VEC_P (dwarf2_per_cu_ptr
);
208 int nr_uniq_abbrev_tables
;
210 int nr_symtab_sharers
;
211 int nr_stmt_less_type_units
;
212 int nr_all_type_units_reallocs
;
215 /* Collection of data recorded per objfile.
216 This hangs off of dwarf2_objfile_data_key. */
218 struct dwarf2_per_objfile
220 struct dwarf2_section_info info
;
221 struct dwarf2_section_info abbrev
;
222 struct dwarf2_section_info line
;
223 struct dwarf2_section_info loc
;
224 struct dwarf2_section_info macinfo
;
225 struct dwarf2_section_info macro
;
226 struct dwarf2_section_info str
;
227 struct dwarf2_section_info ranges
;
228 struct dwarf2_section_info addr
;
229 struct dwarf2_section_info frame
;
230 struct dwarf2_section_info eh_frame
;
231 struct dwarf2_section_info gdb_index
;
233 VEC (dwarf2_section_info_def
) *types
;
236 struct objfile
*objfile
;
238 /* Table of all the compilation units. This is used to locate
239 the target compilation unit of a particular reference. */
240 struct dwarf2_per_cu_data
**all_comp_units
;
242 /* The number of compilation units in ALL_COMP_UNITS. */
245 /* The number of .debug_types-related CUs. */
248 /* The number of elements allocated in all_type_units.
249 If there are skeleton-less TUs, we add them to all_type_units lazily. */
250 int n_allocated_type_units
;
252 /* The .debug_types-related CUs (TUs).
253 This is stored in malloc space because we may realloc it. */
254 struct signatured_type
**all_type_units
;
256 /* Table of struct type_unit_group objects.
257 The hash key is the DW_AT_stmt_list value. */
258 htab_t type_unit_groups
;
260 /* A table mapping .debug_types signatures to its signatured_type entry.
261 This is NULL if the .debug_types section hasn't been read in yet. */
262 htab_t signatured_types
;
264 /* Type unit statistics, to see how well the scaling improvements
266 struct tu_stats tu_stats
;
268 /* A chain of compilation units that are currently read in, so that
269 they can be freed later. */
270 struct dwarf2_per_cu_data
*read_in_chain
;
272 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
273 This is NULL if the table hasn't been allocated yet. */
276 /* Non-zero if we've check for whether there is a DWP file. */
279 /* The DWP file if there is one, or NULL. */
280 struct dwp_file
*dwp_file
;
282 /* The shared '.dwz' file, if one exists. This is used when the
283 original data was compressed using 'dwz -m'. */
284 struct dwz_file
*dwz_file
;
286 /* A flag indicating wether this objfile has a section loaded at a
288 int has_section_at_zero
;
290 /* True if we are using the mapped index,
291 or we are faking it for OBJF_READNOW's sake. */
292 unsigned char using_index
;
294 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
295 struct mapped_index
*index_table
;
297 /* When using index_table, this keeps track of all quick_file_names entries.
298 TUs typically share line table entries with a CU, so we maintain a
299 separate table of all line table entries to support the sharing.
300 Note that while there can be way more TUs than CUs, we've already
301 sorted all the TUs into "type unit groups", grouped by their
302 DW_AT_stmt_list value. Therefore the only sharing done here is with a
303 CU and its associated TU group if there is one. */
304 htab_t quick_file_names_table
;
306 /* Set during partial symbol reading, to prevent queueing of full
308 int reading_partial_symbols
;
310 /* Table mapping type DIEs to their struct type *.
311 This is NULL if not allocated yet.
312 The mapping is done via (CU/TU + DIE offset) -> type. */
313 htab_t die_type_hash
;
315 /* The CUs we recently read. */
316 VEC (dwarf2_per_cu_ptr
) *just_read_cus
;
318 /* Table containing line_header indexed by offset and offset_in_dwz. */
319 htab_t line_header_hash
;
322 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
324 /* Default names of the debugging sections. */
326 /* Note that if the debugging section has been compressed, it might
327 have a name like .zdebug_info. */
329 static const struct dwarf2_debug_sections dwarf2_elf_names
=
331 { ".debug_info", ".zdebug_info" },
332 { ".debug_abbrev", ".zdebug_abbrev" },
333 { ".debug_line", ".zdebug_line" },
334 { ".debug_loc", ".zdebug_loc" },
335 { ".debug_macinfo", ".zdebug_macinfo" },
336 { ".debug_macro", ".zdebug_macro" },
337 { ".debug_str", ".zdebug_str" },
338 { ".debug_ranges", ".zdebug_ranges" },
339 { ".debug_types", ".zdebug_types" },
340 { ".debug_addr", ".zdebug_addr" },
341 { ".debug_frame", ".zdebug_frame" },
342 { ".eh_frame", NULL
},
343 { ".gdb_index", ".zgdb_index" },
347 /* List of DWO/DWP sections. */
349 static const struct dwop_section_names
351 struct dwarf2_section_names abbrev_dwo
;
352 struct dwarf2_section_names info_dwo
;
353 struct dwarf2_section_names line_dwo
;
354 struct dwarf2_section_names loc_dwo
;
355 struct dwarf2_section_names macinfo_dwo
;
356 struct dwarf2_section_names macro_dwo
;
357 struct dwarf2_section_names str_dwo
;
358 struct dwarf2_section_names str_offsets_dwo
;
359 struct dwarf2_section_names types_dwo
;
360 struct dwarf2_section_names cu_index
;
361 struct dwarf2_section_names tu_index
;
365 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
366 { ".debug_info.dwo", ".zdebug_info.dwo" },
367 { ".debug_line.dwo", ".zdebug_line.dwo" },
368 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
369 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
370 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
371 { ".debug_str.dwo", ".zdebug_str.dwo" },
372 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
373 { ".debug_types.dwo", ".zdebug_types.dwo" },
374 { ".debug_cu_index", ".zdebug_cu_index" },
375 { ".debug_tu_index", ".zdebug_tu_index" },
378 /* local data types */
380 /* The data in a compilation unit header, after target2host
381 translation, looks like this. */
382 struct comp_unit_head
386 unsigned char addr_size
;
387 unsigned char signed_addr_p
;
388 sect_offset abbrev_offset
;
390 /* Size of file offsets; either 4 or 8. */
391 unsigned int offset_size
;
393 /* Size of the length field; either 4 or 12. */
394 unsigned int initial_length_size
;
396 /* Offset to the first byte of this compilation unit header in the
397 .debug_info section, for resolving relative reference dies. */
400 /* Offset to first die in this cu from the start of the cu.
401 This will be the first byte following the compilation unit header. */
402 cu_offset first_die_offset
;
405 /* Type used for delaying computation of method physnames.
406 See comments for compute_delayed_physnames. */
407 struct delayed_method_info
409 /* The type to which the method is attached, i.e., its parent class. */
412 /* The index of the method in the type's function fieldlists. */
415 /* The index of the method in the fieldlist. */
418 /* The name of the DIE. */
421 /* The DIE associated with this method. */
422 struct die_info
*die
;
425 typedef struct delayed_method_info delayed_method_info
;
426 DEF_VEC_O (delayed_method_info
);
428 /* Internal state when decoding a particular compilation unit. */
431 /* The objfile containing this compilation unit. */
432 struct objfile
*objfile
;
434 /* The header of the compilation unit. */
435 struct comp_unit_head header
;
437 /* Base address of this compilation unit. */
438 CORE_ADDR base_address
;
440 /* Non-zero if base_address has been set. */
443 /* The language we are debugging. */
444 enum language language
;
445 const struct language_defn
*language_defn
;
447 const char *producer
;
449 /* The generic symbol table building routines have separate lists for
450 file scope symbols and all all other scopes (local scopes). So
451 we need to select the right one to pass to add_symbol_to_list().
452 We do it by keeping a pointer to the correct list in list_in_scope.
454 FIXME: The original dwarf code just treated the file scope as the
455 first local scope, and all other local scopes as nested local
456 scopes, and worked fine. Check to see if we really need to
457 distinguish these in buildsym.c. */
458 struct pending
**list_in_scope
;
460 /* The abbrev table for this CU.
461 Normally this points to the abbrev table in the objfile.
462 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
463 struct abbrev_table
*abbrev_table
;
465 /* Hash table holding all the loaded partial DIEs
466 with partial_die->offset.SECT_OFF as hash. */
469 /* Storage for things with the same lifetime as this read-in compilation
470 unit, including partial DIEs. */
471 struct obstack comp_unit_obstack
;
473 /* When multiple dwarf2_cu structures are living in memory, this field
474 chains them all together, so that they can be released efficiently.
475 We will probably also want a generation counter so that most-recently-used
476 compilation units are cached... */
477 struct dwarf2_per_cu_data
*read_in_chain
;
479 /* Backlink to our per_cu entry. */
480 struct dwarf2_per_cu_data
*per_cu
;
482 /* How many compilation units ago was this CU last referenced? */
485 /* A hash table of DIE cu_offset for following references with
486 die_info->offset.sect_off as hash. */
489 /* Full DIEs if read in. */
490 struct die_info
*dies
;
492 /* A set of pointers to dwarf2_per_cu_data objects for compilation
493 units referenced by this one. Only set during full symbol processing;
494 partial symbol tables do not have dependencies. */
497 /* Header data from the line table, during full symbol processing. */
498 struct line_header
*line_header
;
500 /* A list of methods which need to have physnames computed
501 after all type information has been read. */
502 VEC (delayed_method_info
) *method_list
;
504 /* To be copied to symtab->call_site_htab. */
505 htab_t call_site_htab
;
507 /* Non-NULL if this CU came from a DWO file.
508 There is an invariant here that is important to remember:
509 Except for attributes copied from the top level DIE in the "main"
510 (or "stub") file in preparation for reading the DWO file
511 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
512 Either there isn't a DWO file (in which case this is NULL and the point
513 is moot), or there is and either we're not going to read it (in which
514 case this is NULL) or there is and we are reading it (in which case this
516 struct dwo_unit
*dwo_unit
;
518 /* The DW_AT_addr_base attribute if present, zero otherwise
519 (zero is a valid value though).
520 Note this value comes from the Fission stub CU/TU's DIE. */
523 /* The DW_AT_ranges_base attribute if present, zero otherwise
524 (zero is a valid value though).
525 Note this value comes from the Fission stub CU/TU's DIE.
526 Also note that the value is zero in the non-DWO case so this value can
527 be used without needing to know whether DWO files are in use or not.
528 N.B. This does not apply to DW_AT_ranges appearing in
529 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
530 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
531 DW_AT_ranges_base *would* have to be applied, and we'd have to care
532 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
533 ULONGEST ranges_base
;
535 /* Mark used when releasing cached dies. */
536 unsigned int mark
: 1;
538 /* This CU references .debug_loc. See the symtab->locations_valid field.
539 This test is imperfect as there may exist optimized debug code not using
540 any location list and still facing inlining issues if handled as
541 unoptimized code. For a future better test see GCC PR other/32998. */
542 unsigned int has_loclist
: 1;
544 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
545 if all the producer_is_* fields are valid. This information is cached
546 because profiling CU expansion showed excessive time spent in
547 producer_is_gxx_lt_4_6. */
548 unsigned int checked_producer
: 1;
549 unsigned int producer_is_gxx_lt_4_6
: 1;
550 unsigned int producer_is_gcc_lt_4_3
: 1;
551 unsigned int producer_is_icc
: 1;
553 /* When set, the file that we're processing is known to have
554 debugging info for C++ namespaces. GCC 3.3.x did not produce
555 this information, but later versions do. */
557 unsigned int processing_has_namespace_info
: 1;
560 /* Persistent data held for a compilation unit, even when not
561 processing it. We put a pointer to this structure in the
562 read_symtab_private field of the psymtab. */
564 struct dwarf2_per_cu_data
566 /* The start offset and length of this compilation unit.
567 NOTE: Unlike comp_unit_head.length, this length includes
569 If the DIE refers to a DWO file, this is always of the original die,
574 /* Flag indicating this compilation unit will be read in before
575 any of the current compilation units are processed. */
576 unsigned int queued
: 1;
578 /* This flag will be set when reading partial DIEs if we need to load
579 absolutely all DIEs for this compilation unit, instead of just the ones
580 we think are interesting. It gets set if we look for a DIE in the
581 hash table and don't find it. */
582 unsigned int load_all_dies
: 1;
584 /* Non-zero if this CU is from .debug_types.
585 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
587 unsigned int is_debug_types
: 1;
589 /* Non-zero if this CU is from the .dwz file. */
590 unsigned int is_dwz
: 1;
592 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
593 This flag is only valid if is_debug_types is true.
594 We can't read a CU directly from a DWO file: There are required
595 attributes in the stub. */
596 unsigned int reading_dwo_directly
: 1;
598 /* Non-zero if the TU has been read.
599 This is used to assist the "Stay in DWO Optimization" for Fission:
600 When reading a DWO, it's faster to read TUs from the DWO instead of
601 fetching them from random other DWOs (due to comdat folding).
602 If the TU has already been read, the optimization is unnecessary
603 (and unwise - we don't want to change where gdb thinks the TU lives
605 This flag is only valid if is_debug_types is true. */
606 unsigned int tu_read
: 1;
608 /* The section this CU/TU lives in.
609 If the DIE refers to a DWO file, this is always the original die,
611 struct dwarf2_section_info
*section
;
613 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
614 of the CU cache it gets reset to NULL again. This is left as NULL for
615 dummy CUs (a CU header, but nothing else). */
616 struct dwarf2_cu
*cu
;
618 /* The corresponding objfile.
619 Normally we can get the objfile from dwarf2_per_objfile.
620 However we can enter this file with just a "per_cu" handle. */
621 struct objfile
*objfile
;
623 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
624 is active. Otherwise, the 'psymtab' field is active. */
627 /* The partial symbol table associated with this compilation unit,
628 or NULL for unread partial units. */
629 struct partial_symtab
*psymtab
;
631 /* Data needed by the "quick" functions. */
632 struct dwarf2_per_cu_quick_data
*quick
;
635 /* The CUs we import using DW_TAG_imported_unit. This is filled in
636 while reading psymtabs, used to compute the psymtab dependencies,
637 and then cleared. Then it is filled in again while reading full
638 symbols, and only deleted when the objfile is destroyed.
640 This is also used to work around a difference between the way gold
641 generates .gdb_index version <=7 and the way gdb does. Arguably this
642 is a gold bug. For symbols coming from TUs, gold records in the index
643 the CU that includes the TU instead of the TU itself. This breaks
644 dw2_lookup_symbol: It assumes that if the index says symbol X lives
645 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
646 will find X. Alas TUs live in their own symtab, so after expanding CU Y
647 we need to look in TU Z to find X. Fortunately, this is akin to
648 DW_TAG_imported_unit, so we just use the same mechanism: For
649 .gdb_index version <=7 this also records the TUs that the CU referred
650 to. Concurrently with this change gdb was modified to emit version 8
651 indices so we only pay a price for gold generated indices.
652 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
653 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
656 /* Entry in the signatured_types hash table. */
658 struct signatured_type
660 /* The "per_cu" object of this type.
661 This struct is used iff per_cu.is_debug_types.
662 N.B.: This is the first member so that it's easy to convert pointers
664 struct dwarf2_per_cu_data per_cu
;
666 /* The type's signature. */
669 /* Offset in the TU of the type's DIE, as read from the TU header.
670 If this TU is a DWO stub and the definition lives in a DWO file
671 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
672 cu_offset type_offset_in_tu
;
674 /* Offset in the section of the type's DIE.
675 If the definition lives in a DWO file, this is the offset in the
676 .debug_types.dwo section.
677 The value is zero until the actual value is known.
678 Zero is otherwise not a valid section offset. */
679 sect_offset type_offset_in_section
;
681 /* Type units are grouped by their DW_AT_stmt_list entry so that they
682 can share them. This points to the containing symtab. */
683 struct type_unit_group
*type_unit_group
;
686 The first time we encounter this type we fully read it in and install it
687 in the symbol tables. Subsequent times we only need the type. */
690 /* Containing DWO unit.
691 This field is valid iff per_cu.reading_dwo_directly. */
692 struct dwo_unit
*dwo_unit
;
695 typedef struct signatured_type
*sig_type_ptr
;
696 DEF_VEC_P (sig_type_ptr
);
698 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
699 This includes type_unit_group and quick_file_names. */
701 struct stmt_list_hash
703 /* The DWO unit this table is from or NULL if there is none. */
704 struct dwo_unit
*dwo_unit
;
706 /* Offset in .debug_line or .debug_line.dwo. */
707 sect_offset line_offset
;
710 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
711 an object of this type. */
713 struct type_unit_group
715 /* dwarf2read.c's main "handle" on a TU symtab.
716 To simplify things we create an artificial CU that "includes" all the
717 type units using this stmt_list so that the rest of the code still has
718 a "per_cu" handle on the symtab.
719 This PER_CU is recognized by having no section. */
720 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
721 struct dwarf2_per_cu_data per_cu
;
723 /* The TUs that share this DW_AT_stmt_list entry.
724 This is added to while parsing type units to build partial symtabs,
725 and is deleted afterwards and not used again. */
726 VEC (sig_type_ptr
) *tus
;
728 /* The compunit symtab.
729 Type units in a group needn't all be defined in the same source file,
730 so we create an essentially anonymous symtab as the compunit symtab. */
731 struct compunit_symtab
*compunit_symtab
;
733 /* The data used to construct the hash key. */
734 struct stmt_list_hash hash
;
736 /* The number of symtabs from the line header.
737 The value here must match line_header.num_file_names. */
738 unsigned int num_symtabs
;
740 /* The symbol tables for this TU (obtained from the files listed in
742 WARNING: The order of entries here must match the order of entries
743 in the line header. After the first TU using this type_unit_group, the
744 line header for the subsequent TUs is recreated from this. This is done
745 because we need to use the same symtabs for each TU using the same
746 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
747 there's no guarantee the line header doesn't have duplicate entries. */
748 struct symtab
**symtabs
;
751 /* These sections are what may appear in a (real or virtual) DWO file. */
755 struct dwarf2_section_info abbrev
;
756 struct dwarf2_section_info line
;
757 struct dwarf2_section_info loc
;
758 struct dwarf2_section_info macinfo
;
759 struct dwarf2_section_info macro
;
760 struct dwarf2_section_info str
;
761 struct dwarf2_section_info str_offsets
;
762 /* In the case of a virtual DWO file, these two are unused. */
763 struct dwarf2_section_info info
;
764 VEC (dwarf2_section_info_def
) *types
;
767 /* CUs/TUs in DWP/DWO files. */
771 /* Backlink to the containing struct dwo_file. */
772 struct dwo_file
*dwo_file
;
774 /* The "id" that distinguishes this CU/TU.
775 .debug_info calls this "dwo_id", .debug_types calls this "signature".
776 Since signatures came first, we stick with it for consistency. */
779 /* The section this CU/TU lives in, in the DWO file. */
780 struct dwarf2_section_info
*section
;
782 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
786 /* For types, offset in the type's DIE of the type defined by this TU. */
787 cu_offset type_offset_in_tu
;
790 /* include/dwarf2.h defines the DWP section codes.
791 It defines a max value but it doesn't define a min value, which we
792 use for error checking, so provide one. */
794 enum dwp_v2_section_ids
799 /* Data for one DWO file.
801 This includes virtual DWO files (a virtual DWO file is a DWO file as it
802 appears in a DWP file). DWP files don't really have DWO files per se -
803 comdat folding of types "loses" the DWO file they came from, and from
804 a high level view DWP files appear to contain a mass of random types.
805 However, to maintain consistency with the non-DWP case we pretend DWP
806 files contain virtual DWO files, and we assign each TU with one virtual
807 DWO file (generally based on the line and abbrev section offsets -
808 a heuristic that seems to work in practice). */
812 /* The DW_AT_GNU_dwo_name attribute.
813 For virtual DWO files the name is constructed from the section offsets
814 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
815 from related CU+TUs. */
816 const char *dwo_name
;
818 /* The DW_AT_comp_dir attribute. */
819 const char *comp_dir
;
821 /* The bfd, when the file is open. Otherwise this is NULL.
822 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
825 /* The sections that make up this DWO file.
826 Remember that for virtual DWO files in DWP V2, these are virtual
827 sections (for lack of a better name). */
828 struct dwo_sections sections
;
830 /* The CU in the file.
831 We only support one because having more than one requires hacking the
832 dwo_name of each to match, which is highly unlikely to happen.
833 Doing this means all TUs can share comp_dir: We also assume that
834 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
837 /* Table of TUs in the file.
838 Each element is a struct dwo_unit. */
842 /* These sections are what may appear in a DWP file. */
846 /* These are used by both DWP version 1 and 2. */
847 struct dwarf2_section_info str
;
848 struct dwarf2_section_info cu_index
;
849 struct dwarf2_section_info tu_index
;
851 /* These are only used by DWP version 2 files.
852 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
853 sections are referenced by section number, and are not recorded here.
854 In DWP version 2 there is at most one copy of all these sections, each
855 section being (effectively) comprised of the concatenation of all of the
856 individual sections that exist in the version 1 format.
857 To keep the code simple we treat each of these concatenated pieces as a
858 section itself (a virtual section?). */
859 struct dwarf2_section_info abbrev
;
860 struct dwarf2_section_info info
;
861 struct dwarf2_section_info line
;
862 struct dwarf2_section_info loc
;
863 struct dwarf2_section_info macinfo
;
864 struct dwarf2_section_info macro
;
865 struct dwarf2_section_info str_offsets
;
866 struct dwarf2_section_info types
;
869 /* These sections are what may appear in a virtual DWO file in DWP version 1.
870 A virtual DWO file is a DWO file as it appears in a DWP file. */
872 struct virtual_v1_dwo_sections
874 struct dwarf2_section_info abbrev
;
875 struct dwarf2_section_info line
;
876 struct dwarf2_section_info loc
;
877 struct dwarf2_section_info macinfo
;
878 struct dwarf2_section_info macro
;
879 struct dwarf2_section_info str_offsets
;
880 /* Each DWP hash table entry records one CU or one TU.
881 That is recorded here, and copied to dwo_unit.section. */
882 struct dwarf2_section_info info_or_types
;
885 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
886 In version 2, the sections of the DWO files are concatenated together
887 and stored in one section of that name. Thus each ELF section contains
888 several "virtual" sections. */
890 struct virtual_v2_dwo_sections
892 bfd_size_type abbrev_offset
;
893 bfd_size_type abbrev_size
;
895 bfd_size_type line_offset
;
896 bfd_size_type line_size
;
898 bfd_size_type loc_offset
;
899 bfd_size_type loc_size
;
901 bfd_size_type macinfo_offset
;
902 bfd_size_type macinfo_size
;
904 bfd_size_type macro_offset
;
905 bfd_size_type macro_size
;
907 bfd_size_type str_offsets_offset
;
908 bfd_size_type str_offsets_size
;
910 /* Each DWP hash table entry records one CU or one TU.
911 That is recorded here, and copied to dwo_unit.section. */
912 bfd_size_type info_or_types_offset
;
913 bfd_size_type info_or_types_size
;
916 /* Contents of DWP hash tables. */
918 struct dwp_hash_table
920 uint32_t version
, nr_columns
;
921 uint32_t nr_units
, nr_slots
;
922 const gdb_byte
*hash_table
, *unit_table
;
927 const gdb_byte
*indices
;
931 /* This is indexed by column number and gives the id of the section
933 #define MAX_NR_V2_DWO_SECTIONS \
934 (1 /* .debug_info or .debug_types */ \
935 + 1 /* .debug_abbrev */ \
936 + 1 /* .debug_line */ \
937 + 1 /* .debug_loc */ \
938 + 1 /* .debug_str_offsets */ \
939 + 1 /* .debug_macro or .debug_macinfo */)
940 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
941 const gdb_byte
*offsets
;
942 const gdb_byte
*sizes
;
947 /* Data for one DWP file. */
951 /* Name of the file. */
954 /* File format version. */
960 /* Section info for this file. */
961 struct dwp_sections sections
;
963 /* Table of CUs in the file. */
964 const struct dwp_hash_table
*cus
;
966 /* Table of TUs in the file. */
967 const struct dwp_hash_table
*tus
;
969 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
973 /* Table to map ELF section numbers to their sections.
974 This is only needed for the DWP V1 file format. */
975 unsigned int num_sections
;
976 asection
**elf_sections
;
979 /* This represents a '.dwz' file. */
983 /* A dwz file can only contain a few sections. */
984 struct dwarf2_section_info abbrev
;
985 struct dwarf2_section_info info
;
986 struct dwarf2_section_info str
;
987 struct dwarf2_section_info line
;
988 struct dwarf2_section_info macro
;
989 struct dwarf2_section_info gdb_index
;
995 /* Struct used to pass misc. parameters to read_die_and_children, et
996 al. which are used for both .debug_info and .debug_types dies.
997 All parameters here are unchanging for the life of the call. This
998 struct exists to abstract away the constant parameters of die reading. */
1000 struct die_reader_specs
1002 /* The bfd of die_section. */
1005 /* The CU of the DIE we are parsing. */
1006 struct dwarf2_cu
*cu
;
1008 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1009 struct dwo_file
*dwo_file
;
1011 /* The section the die comes from.
1012 This is either .debug_info or .debug_types, or the .dwo variants. */
1013 struct dwarf2_section_info
*die_section
;
1015 /* die_section->buffer. */
1016 const gdb_byte
*buffer
;
1018 /* The end of the buffer. */
1019 const gdb_byte
*buffer_end
;
1021 /* The value of the DW_AT_comp_dir attribute. */
1022 const char *comp_dir
;
1025 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1026 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
1027 const gdb_byte
*info_ptr
,
1028 struct die_info
*comp_unit_die
,
1035 unsigned int dir_index
;
1036 unsigned int mod_time
;
1037 unsigned int length
;
1038 /* Non-zero if referenced by the Line Number Program. */
1040 /* The associated symbol table, if any. */
1041 struct symtab
*symtab
;
1044 /* The line number information for a compilation unit (found in the
1045 .debug_line section) begins with a "statement program header",
1046 which contains the following information. */
1049 /* Offset of line number information in .debug_line section. */
1052 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1053 unsigned offset_in_dwz
: 1;
1055 unsigned int total_length
;
1056 unsigned short version
;
1057 unsigned int header_length
;
1058 unsigned char minimum_instruction_length
;
1059 unsigned char maximum_ops_per_instruction
;
1060 unsigned char default_is_stmt
;
1062 unsigned char line_range
;
1063 unsigned char opcode_base
;
1065 /* standard_opcode_lengths[i] is the number of operands for the
1066 standard opcode whose value is i. This means that
1067 standard_opcode_lengths[0] is unused, and the last meaningful
1068 element is standard_opcode_lengths[opcode_base - 1]. */
1069 unsigned char *standard_opcode_lengths
;
1071 /* The include_directories table. NOTE! These strings are not
1072 allocated with xmalloc; instead, they are pointers into
1073 debug_line_buffer. If you try to free them, `free' will get
1075 unsigned int num_include_dirs
, include_dirs_size
;
1076 const char **include_dirs
;
1078 /* The file_names table. NOTE! These strings are not allocated
1079 with xmalloc; instead, they are pointers into debug_line_buffer.
1080 Don't try to free them directly. */
1081 unsigned int num_file_names
, file_names_size
;
1082 struct file_entry
*file_names
;
1084 /* The start and end of the statement program following this
1085 header. These point into dwarf2_per_objfile->line_buffer. */
1086 const gdb_byte
*statement_program_start
, *statement_program_end
;
1089 /* When we construct a partial symbol table entry we only
1090 need this much information. */
1091 struct partial_die_info
1093 /* Offset of this DIE. */
1096 /* DWARF-2 tag for this DIE. */
1097 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1099 /* Assorted flags describing the data found in this DIE. */
1100 unsigned int has_children
: 1;
1101 unsigned int is_external
: 1;
1102 unsigned int is_declaration
: 1;
1103 unsigned int has_type
: 1;
1104 unsigned int has_specification
: 1;
1105 unsigned int has_pc_info
: 1;
1106 unsigned int may_be_inlined
: 1;
1108 /* This DIE has been marked DW_AT_main_subprogram. */
1109 unsigned int main_subprogram
: 1;
1111 /* Flag set if the SCOPE field of this structure has been
1113 unsigned int scope_set
: 1;
1115 /* Flag set if the DIE has a byte_size attribute. */
1116 unsigned int has_byte_size
: 1;
1118 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1119 unsigned int has_const_value
: 1;
1121 /* Flag set if any of the DIE's children are template arguments. */
1122 unsigned int has_template_arguments
: 1;
1124 /* Flag set if fixup_partial_die has been called on this die. */
1125 unsigned int fixup_called
: 1;
1127 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1128 unsigned int is_dwz
: 1;
1130 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1131 unsigned int spec_is_dwz
: 1;
1133 /* The name of this DIE. Normally the value of DW_AT_name, but
1134 sometimes a default name for unnamed DIEs. */
1137 /* The linkage name, if present. */
1138 const char *linkage_name
;
1140 /* The scope to prepend to our children. This is generally
1141 allocated on the comp_unit_obstack, so will disappear
1142 when this compilation unit leaves the cache. */
1145 /* Some data associated with the partial DIE. The tag determines
1146 which field is live. */
1149 /* The location description associated with this DIE, if any. */
1150 struct dwarf_block
*locdesc
;
1151 /* The offset of an import, for DW_TAG_imported_unit. */
1155 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1159 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1160 DW_AT_sibling, if any. */
1161 /* NOTE: This member isn't strictly necessary, read_partial_die could
1162 return DW_AT_sibling values to its caller load_partial_dies. */
1163 const gdb_byte
*sibling
;
1165 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1166 DW_AT_specification (or DW_AT_abstract_origin or
1167 DW_AT_extension). */
1168 sect_offset spec_offset
;
1170 /* Pointers to this DIE's parent, first child, and next sibling,
1172 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
1175 /* This data structure holds the information of an abbrev. */
1178 unsigned int number
; /* number identifying abbrev */
1179 enum dwarf_tag tag
; /* dwarf tag */
1180 unsigned short has_children
; /* boolean */
1181 unsigned short num_attrs
; /* number of attributes */
1182 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1183 struct abbrev_info
*next
; /* next in chain */
1188 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1189 ENUM_BITFIELD(dwarf_form
) form
: 16;
1192 /* Size of abbrev_table.abbrev_hash_table. */
1193 #define ABBREV_HASH_SIZE 121
1195 /* Top level data structure to contain an abbreviation table. */
1199 /* Where the abbrev table came from.
1200 This is used as a sanity check when the table is used. */
1203 /* Storage for the abbrev table. */
1204 struct obstack abbrev_obstack
;
1206 /* Hash table of abbrevs.
1207 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1208 It could be statically allocated, but the previous code didn't so we
1210 struct abbrev_info
**abbrevs
;
1213 /* Attributes have a name and a value. */
1216 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1217 ENUM_BITFIELD(dwarf_form
) form
: 15;
1219 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1220 field should be in u.str (existing only for DW_STRING) but it is kept
1221 here for better struct attribute alignment. */
1222 unsigned int string_is_canonical
: 1;
1227 struct dwarf_block
*blk
;
1236 /* This data structure holds a complete die structure. */
1239 /* DWARF-2 tag for this DIE. */
1240 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1242 /* Number of attributes */
1243 unsigned char num_attrs
;
1245 /* True if we're presently building the full type name for the
1246 type derived from this DIE. */
1247 unsigned char building_fullname
: 1;
1249 /* True if this die is in process. PR 16581. */
1250 unsigned char in_process
: 1;
1253 unsigned int abbrev
;
1255 /* Offset in .debug_info or .debug_types section. */
1258 /* The dies in a compilation unit form an n-ary tree. PARENT
1259 points to this die's parent; CHILD points to the first child of
1260 this node; and all the children of a given node are chained
1261 together via their SIBLING fields. */
1262 struct die_info
*child
; /* Its first child, if any. */
1263 struct die_info
*sibling
; /* Its next sibling, if any. */
1264 struct die_info
*parent
; /* Its parent, if any. */
1266 /* An array of attributes, with NUM_ATTRS elements. There may be
1267 zero, but it's not common and zero-sized arrays are not
1268 sufficiently portable C. */
1269 struct attribute attrs
[1];
1272 /* Get at parts of an attribute structure. */
1274 #define DW_STRING(attr) ((attr)->u.str)
1275 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1276 #define DW_UNSND(attr) ((attr)->u.unsnd)
1277 #define DW_BLOCK(attr) ((attr)->u.blk)
1278 #define DW_SND(attr) ((attr)->u.snd)
1279 #define DW_ADDR(attr) ((attr)->u.addr)
1280 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1282 /* Blocks are a bunch of untyped bytes. */
1287 /* Valid only if SIZE is not zero. */
1288 const gdb_byte
*data
;
1291 #ifndef ATTR_ALLOC_CHUNK
1292 #define ATTR_ALLOC_CHUNK 4
1295 /* Allocate fields for structs, unions and enums in this size. */
1296 #ifndef DW_FIELD_ALLOC_CHUNK
1297 #define DW_FIELD_ALLOC_CHUNK 4
1300 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1301 but this would require a corresponding change in unpack_field_as_long
1303 static int bits_per_byte
= 8;
1307 struct nextfield
*next
;
1315 struct nextfnfield
*next
;
1316 struct fn_field fnfield
;
1323 struct nextfnfield
*head
;
1326 struct typedef_field_list
1328 struct typedef_field field
;
1329 struct typedef_field_list
*next
;
1332 /* The routines that read and process dies for a C struct or C++ class
1333 pass lists of data member fields and lists of member function fields
1334 in an instance of a field_info structure, as defined below. */
1337 /* List of data member and baseclasses fields. */
1338 struct nextfield
*fields
, *baseclasses
;
1340 /* Number of fields (including baseclasses). */
1343 /* Number of baseclasses. */
1346 /* Set if the accesibility of one of the fields is not public. */
1347 int non_public_fields
;
1349 /* Member function fields array, entries are allocated in the order they
1350 are encountered in the object file. */
1351 struct nextfnfield
*fnfields
;
1353 /* Member function fieldlist array, contains name of possibly overloaded
1354 member function, number of overloaded member functions and a pointer
1355 to the head of the member function field chain. */
1356 struct fnfieldlist
*fnfieldlists
;
1358 /* Number of entries in the fnfieldlists array. */
1361 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1362 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1363 struct typedef_field_list
*typedef_field_list
;
1364 unsigned typedef_field_list_count
;
1367 /* One item on the queue of compilation units to read in full symbols
1369 struct dwarf2_queue_item
1371 struct dwarf2_per_cu_data
*per_cu
;
1372 enum language pretend_language
;
1373 struct dwarf2_queue_item
*next
;
1376 /* The current queue. */
1377 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1379 /* Loaded secondary compilation units are kept in memory until they
1380 have not been referenced for the processing of this many
1381 compilation units. Set this to zero to disable caching. Cache
1382 sizes of up to at least twenty will improve startup time for
1383 typical inter-CU-reference binaries, at an obvious memory cost. */
1384 static int dwarf_max_cache_age
= 5;
1386 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1387 struct cmd_list_element
*c
, const char *value
)
1389 fprintf_filtered (file
, _("The upper bound on the age of cached "
1390 "DWARF compilation units is %s.\n"),
1394 /* local function prototypes */
1396 static const char *get_section_name (const struct dwarf2_section_info
*);
1398 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1400 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1402 static void dwarf2_find_base_address (struct die_info
*die
,
1403 struct dwarf2_cu
*cu
);
1405 static struct partial_symtab
*create_partial_symtab
1406 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1408 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1410 static void scan_partial_symbols (struct partial_die_info
*,
1411 CORE_ADDR
*, CORE_ADDR
*,
1412 int, struct dwarf2_cu
*);
1414 static void add_partial_symbol (struct partial_die_info
*,
1415 struct dwarf2_cu
*);
1417 static void add_partial_namespace (struct partial_die_info
*pdi
,
1418 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1419 int set_addrmap
, struct dwarf2_cu
*cu
);
1421 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1422 CORE_ADDR
*highpc
, int set_addrmap
,
1423 struct dwarf2_cu
*cu
);
1425 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1426 struct dwarf2_cu
*cu
);
1428 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1429 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1430 int need_pc
, struct dwarf2_cu
*cu
);
1432 static void dwarf2_read_symtab (struct partial_symtab
*,
1435 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1437 static struct abbrev_info
*abbrev_table_lookup_abbrev
1438 (const struct abbrev_table
*, unsigned int);
1440 static struct abbrev_table
*abbrev_table_read_table
1441 (struct dwarf2_section_info
*, sect_offset
);
1443 static void abbrev_table_free (struct abbrev_table
*);
1445 static void abbrev_table_free_cleanup (void *);
1447 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1448 struct dwarf2_section_info
*);
1450 static void dwarf2_free_abbrev_table (void *);
1452 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1454 static struct partial_die_info
*load_partial_dies
1455 (const struct die_reader_specs
*, const gdb_byte
*, int);
1457 static const gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1458 struct partial_die_info
*,
1459 struct abbrev_info
*,
1463 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1464 struct dwarf2_cu
*);
1466 static void fixup_partial_die (struct partial_die_info
*,
1467 struct dwarf2_cu
*);
1469 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1470 struct attribute
*, struct attr_abbrev
*,
1473 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1475 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1477 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1479 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1481 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1483 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1486 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1488 static LONGEST read_checked_initial_length_and_offset
1489 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1490 unsigned int *, unsigned int *);
1492 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1493 const struct comp_unit_head
*,
1496 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1498 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1501 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1503 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1505 static const char *read_indirect_string (bfd
*, const gdb_byte
*,
1506 const struct comp_unit_head
*,
1509 static const char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1511 static ULONGEST
read_unsigned_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1513 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1515 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1519 static const char *read_str_index (const struct die_reader_specs
*reader
,
1520 ULONGEST str_index
);
1522 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1524 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1525 struct dwarf2_cu
*);
1527 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1530 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1531 struct dwarf2_cu
*cu
);
1533 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1534 struct dwarf2_cu
*cu
);
1536 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1538 static struct die_info
*die_specification (struct die_info
*die
,
1539 struct dwarf2_cu
**);
1541 static void free_line_header (struct line_header
*lh
);
1543 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1544 struct dwarf2_cu
*cu
);
1546 static void dwarf_decode_lines (struct line_header
*, const char *,
1547 struct dwarf2_cu
*, struct partial_symtab
*,
1548 CORE_ADDR
, int decode_mapping
);
1550 static void dwarf2_start_subfile (const char *, const char *);
1552 static struct compunit_symtab
*dwarf2_start_symtab (struct dwarf2_cu
*,
1553 const char *, const char *,
1556 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1557 struct dwarf2_cu
*);
1559 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1560 struct dwarf2_cu
*, struct symbol
*);
1562 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1563 struct dwarf2_cu
*);
1565 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1568 struct obstack
*obstack
,
1569 struct dwarf2_cu
*cu
, LONGEST
*value
,
1570 const gdb_byte
**bytes
,
1571 struct dwarf2_locexpr_baton
**baton
);
1573 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1575 static int need_gnat_info (struct dwarf2_cu
*);
1577 static struct type
*die_descriptive_type (struct die_info
*,
1578 struct dwarf2_cu
*);
1580 static void set_descriptive_type (struct type
*, struct die_info
*,
1581 struct dwarf2_cu
*);
1583 static struct type
*die_containing_type (struct die_info
*,
1584 struct dwarf2_cu
*);
1586 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1587 struct dwarf2_cu
*);
1589 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1591 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1593 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1595 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1596 const char *suffix
, int physname
,
1597 struct dwarf2_cu
*cu
);
1599 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1601 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1603 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1605 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1607 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1609 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1610 struct dwarf2_cu
*, struct partial_symtab
*);
1612 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1613 values. Keep the items ordered with increasing constraints compliance. */
1616 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1617 PC_BOUNDS_NOT_PRESENT
,
1619 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1620 were present but they do not form a valid range of PC addresses. */
1623 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1626 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1630 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1631 CORE_ADDR
*, CORE_ADDR
*,
1633 struct partial_symtab
*);
1635 static void get_scope_pc_bounds (struct die_info
*,
1636 CORE_ADDR
*, CORE_ADDR
*,
1637 struct dwarf2_cu
*);
1639 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1640 CORE_ADDR
, struct dwarf2_cu
*);
1642 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1643 struct dwarf2_cu
*);
1645 static void dwarf2_attach_fields_to_type (struct field_info
*,
1646 struct type
*, struct dwarf2_cu
*);
1648 static void dwarf2_add_member_fn (struct field_info
*,
1649 struct die_info
*, struct type
*,
1650 struct dwarf2_cu
*);
1652 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1654 struct dwarf2_cu
*);
1656 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1658 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1660 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1662 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1664 static struct using_direct
**using_directives (enum language
);
1666 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1668 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1670 static struct type
*read_module_type (struct die_info
*die
,
1671 struct dwarf2_cu
*cu
);
1673 static const char *namespace_name (struct die_info
*die
,
1674 int *is_anonymous
, struct dwarf2_cu
*);
1676 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1678 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1680 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1681 struct dwarf2_cu
*);
1683 static struct die_info
*read_die_and_siblings_1
1684 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1687 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1688 const gdb_byte
*info_ptr
,
1689 const gdb_byte
**new_info_ptr
,
1690 struct die_info
*parent
);
1692 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1693 struct die_info
**, const gdb_byte
*,
1696 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1697 struct die_info
**, const gdb_byte
*,
1700 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1702 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1705 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1707 static const char *dwarf2_full_name (const char *name
,
1708 struct die_info
*die
,
1709 struct dwarf2_cu
*cu
);
1711 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1712 struct dwarf2_cu
*cu
);
1714 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1715 struct dwarf2_cu
**);
1717 static const char *dwarf_tag_name (unsigned int);
1719 static const char *dwarf_attr_name (unsigned int);
1721 static const char *dwarf_form_name (unsigned int);
1723 static char *dwarf_bool_name (unsigned int);
1725 static const char *dwarf_type_encoding_name (unsigned int);
1727 static struct die_info
*sibling_die (struct die_info
*);
1729 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1731 static void dump_die_for_error (struct die_info
*);
1733 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1736 /*static*/ void dump_die (struct die_info
*, int max_level
);
1738 static void store_in_ref_table (struct die_info
*,
1739 struct dwarf2_cu
*);
1741 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1743 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1745 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1746 const struct attribute
*,
1747 struct dwarf2_cu
**);
1749 static struct die_info
*follow_die_ref (struct die_info
*,
1750 const struct attribute
*,
1751 struct dwarf2_cu
**);
1753 static struct die_info
*follow_die_sig (struct die_info
*,
1754 const struct attribute
*,
1755 struct dwarf2_cu
**);
1757 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1758 struct dwarf2_cu
*);
1760 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1761 const struct attribute
*,
1762 struct dwarf2_cu
*);
1764 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1766 static void read_signatured_type (struct signatured_type
*);
1768 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1769 struct die_info
*die
, struct dwarf2_cu
*cu
,
1770 struct dynamic_prop
*prop
);
1772 /* memory allocation interface */
1774 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1776 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1778 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1780 static int attr_form_is_block (const struct attribute
*);
1782 static int attr_form_is_section_offset (const struct attribute
*);
1784 static int attr_form_is_constant (const struct attribute
*);
1786 static int attr_form_is_ref (const struct attribute
*);
1788 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1789 struct dwarf2_loclist_baton
*baton
,
1790 const struct attribute
*attr
);
1792 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1794 struct dwarf2_cu
*cu
,
1797 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1798 const gdb_byte
*info_ptr
,
1799 struct abbrev_info
*abbrev
);
1801 static void free_stack_comp_unit (void *);
1803 static hashval_t
partial_die_hash (const void *item
);
1805 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1807 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1808 (sect_offset offset
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
1810 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1811 struct dwarf2_per_cu_data
*per_cu
);
1813 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1814 struct die_info
*comp_unit_die
,
1815 enum language pretend_language
);
1817 static void free_heap_comp_unit (void *);
1819 static void free_cached_comp_units (void *);
1821 static void age_cached_comp_units (void);
1823 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1825 static struct type
*set_die_type (struct die_info
*, struct type
*,
1826 struct dwarf2_cu
*);
1828 static void create_all_comp_units (struct objfile
*);
1830 static int create_all_type_units (struct objfile
*);
1832 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1835 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1838 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1841 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1842 struct dwarf2_per_cu_data
*);
1844 static void dwarf2_mark (struct dwarf2_cu
*);
1846 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1848 static struct type
*get_die_type_at_offset (sect_offset
,
1849 struct dwarf2_per_cu_data
*);
1851 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1853 static void dwarf2_release_queue (void *dummy
);
1855 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1856 enum language pretend_language
);
1858 static void process_queue (void);
1860 static void find_file_and_directory (struct die_info
*die
,
1861 struct dwarf2_cu
*cu
,
1862 const char **name
, const char **comp_dir
);
1864 static char *file_full_name (int file
, struct line_header
*lh
,
1865 const char *comp_dir
);
1867 static const gdb_byte
*read_and_check_comp_unit_head
1868 (struct comp_unit_head
*header
,
1869 struct dwarf2_section_info
*section
,
1870 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1871 int is_debug_types_section
);
1873 static void init_cutu_and_read_dies
1874 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1875 int use_existing_cu
, int keep
,
1876 die_reader_func_ftype
*die_reader_func
, void *data
);
1878 static void init_cutu_and_read_dies_simple
1879 (struct dwarf2_per_cu_data
*this_cu
,
1880 die_reader_func_ftype
*die_reader_func
, void *data
);
1882 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1884 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1886 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1887 (struct dwp_file
*dwp_file
, const char *comp_dir
,
1888 ULONGEST signature
, int is_debug_types
);
1890 static struct dwp_file
*get_dwp_file (void);
1892 static struct dwo_unit
*lookup_dwo_comp_unit
1893 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1895 static struct dwo_unit
*lookup_dwo_type_unit
1896 (struct signatured_type
*, const char *, const char *);
1898 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
1900 static void free_dwo_file_cleanup (void *);
1902 static void process_cu_includes (void);
1904 static void check_producer (struct dwarf2_cu
*cu
);
1906 static void free_line_header_voidp (void *arg
);
1908 /* Various complaints about symbol reading that don't abort the process. */
1911 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1913 complaint (&symfile_complaints
,
1914 _("statement list doesn't fit in .debug_line section"));
1918 dwarf2_debug_line_missing_file_complaint (void)
1920 complaint (&symfile_complaints
,
1921 _(".debug_line section has line data without a file"));
1925 dwarf2_debug_line_missing_end_sequence_complaint (void)
1927 complaint (&symfile_complaints
,
1928 _(".debug_line section has line "
1929 "program sequence without an end"));
1933 dwarf2_complex_location_expr_complaint (void)
1935 complaint (&symfile_complaints
, _("location expression too complex"));
1939 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1942 complaint (&symfile_complaints
,
1943 _("const value length mismatch for '%s', got %d, expected %d"),
1948 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1950 complaint (&symfile_complaints
,
1951 _("debug info runs off end of %s section"
1953 get_section_name (section
),
1954 get_section_file_name (section
));
1958 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1960 complaint (&symfile_complaints
,
1961 _("macro debug info contains a "
1962 "malformed macro definition:\n`%s'"),
1967 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1969 complaint (&symfile_complaints
,
1970 _("invalid attribute class or form for '%s' in '%s'"),
1974 /* Hash function for line_header_hash. */
1977 line_header_hash (const struct line_header
*ofs
)
1979 return ofs
->offset
.sect_off
^ ofs
->offset_in_dwz
;
1982 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1985 line_header_hash_voidp (const void *item
)
1987 const struct line_header
*ofs
= (const struct line_header
*) item
;
1989 return line_header_hash (ofs
);
1992 /* Equality function for line_header_hash. */
1995 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1997 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1998 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
2000 return (ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
2001 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
2007 /* Convert VALUE between big- and little-endian. */
2009 byte_swap (offset_type value
)
2013 result
= (value
& 0xff) << 24;
2014 result
|= (value
& 0xff00) << 8;
2015 result
|= (value
& 0xff0000) >> 8;
2016 result
|= (value
& 0xff000000) >> 24;
2020 #define MAYBE_SWAP(V) byte_swap (V)
2023 #define MAYBE_SWAP(V) (V)
2024 #endif /* WORDS_BIGENDIAN */
2026 /* Read the given attribute value as an address, taking the attribute's
2027 form into account. */
2030 attr_value_as_address (struct attribute
*attr
)
2034 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_GNU_addr_index
)
2036 /* Aside from a few clearly defined exceptions, attributes that
2037 contain an address must always be in DW_FORM_addr form.
2038 Unfortunately, some compilers happen to be violating this
2039 requirement by encoding addresses using other forms, such
2040 as DW_FORM_data4 for example. For those broken compilers,
2041 we try to do our best, without any guarantee of success,
2042 to interpret the address correctly. It would also be nice
2043 to generate a complaint, but that would require us to maintain
2044 a list of legitimate cases where a non-address form is allowed,
2045 as well as update callers to pass in at least the CU's DWARF
2046 version. This is more overhead than what we're willing to
2047 expand for a pretty rare case. */
2048 addr
= DW_UNSND (attr
);
2051 addr
= DW_ADDR (attr
);
2056 /* The suffix for an index file. */
2057 #define INDEX_SUFFIX ".gdb-index"
2059 /* Try to locate the sections we need for DWARF 2 debugging
2060 information and return true if we have enough to do something.
2061 NAMES points to the dwarf2 section names, or is NULL if the standard
2062 ELF names are used. */
2065 dwarf2_has_info (struct objfile
*objfile
,
2066 const struct dwarf2_debug_sections
*names
)
2068 dwarf2_per_objfile
= ((struct dwarf2_per_objfile
*)
2069 objfile_data (objfile
, dwarf2_objfile_data_key
));
2070 if (!dwarf2_per_objfile
)
2072 /* Initialize per-objfile state. */
2073 struct dwarf2_per_objfile
*data
2074 = XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_per_objfile
);
2076 memset (data
, 0, sizeof (*data
));
2077 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
2078 dwarf2_per_objfile
= data
;
2080 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
2082 dwarf2_per_objfile
->objfile
= objfile
;
2084 return (!dwarf2_per_objfile
->info
.is_virtual
2085 && dwarf2_per_objfile
->info
.s
.section
!= NULL
2086 && !dwarf2_per_objfile
->abbrev
.is_virtual
2087 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
2090 /* Return the containing section of virtual section SECTION. */
2092 static struct dwarf2_section_info
*
2093 get_containing_section (const struct dwarf2_section_info
*section
)
2095 gdb_assert (section
->is_virtual
);
2096 return section
->s
.containing_section
;
2099 /* Return the bfd owner of SECTION. */
2102 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2104 if (section
->is_virtual
)
2106 section
= get_containing_section (section
);
2107 gdb_assert (!section
->is_virtual
);
2109 return section
->s
.section
->owner
;
2112 /* Return the bfd section of SECTION.
2113 Returns NULL if the section is not present. */
2116 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2118 if (section
->is_virtual
)
2120 section
= get_containing_section (section
);
2121 gdb_assert (!section
->is_virtual
);
2123 return section
->s
.section
;
2126 /* Return the name of SECTION. */
2129 get_section_name (const struct dwarf2_section_info
*section
)
2131 asection
*sectp
= get_section_bfd_section (section
);
2133 gdb_assert (sectp
!= NULL
);
2134 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2137 /* Return the name of the file SECTION is in. */
2140 get_section_file_name (const struct dwarf2_section_info
*section
)
2142 bfd
*abfd
= get_section_bfd_owner (section
);
2144 return bfd_get_filename (abfd
);
2147 /* Return the id of SECTION.
2148 Returns 0 if SECTION doesn't exist. */
2151 get_section_id (const struct dwarf2_section_info
*section
)
2153 asection
*sectp
= get_section_bfd_section (section
);
2160 /* Return the flags of SECTION.
2161 SECTION (or containing section if this is a virtual section) must exist. */
2164 get_section_flags (const struct dwarf2_section_info
*section
)
2166 asection
*sectp
= get_section_bfd_section (section
);
2168 gdb_assert (sectp
!= NULL
);
2169 return bfd_get_section_flags (sectp
->owner
, sectp
);
2172 /* When loading sections, we look either for uncompressed section or for
2173 compressed section names. */
2176 section_is_p (const char *section_name
,
2177 const struct dwarf2_section_names
*names
)
2179 if (names
->normal
!= NULL
2180 && strcmp (section_name
, names
->normal
) == 0)
2182 if (names
->compressed
!= NULL
2183 && strcmp (section_name
, names
->compressed
) == 0)
2188 /* This function is mapped across the sections and remembers the
2189 offset and size of each of the debugging sections we are interested
2193 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
2195 const struct dwarf2_debug_sections
*names
;
2196 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2199 names
= &dwarf2_elf_names
;
2201 names
= (const struct dwarf2_debug_sections
*) vnames
;
2203 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2206 else if (section_is_p (sectp
->name
, &names
->info
))
2208 dwarf2_per_objfile
->info
.s
.section
= sectp
;
2209 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
2211 else if (section_is_p (sectp
->name
, &names
->abbrev
))
2213 dwarf2_per_objfile
->abbrev
.s
.section
= sectp
;
2214 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
2216 else if (section_is_p (sectp
->name
, &names
->line
))
2218 dwarf2_per_objfile
->line
.s
.section
= sectp
;
2219 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
2221 else if (section_is_p (sectp
->name
, &names
->loc
))
2223 dwarf2_per_objfile
->loc
.s
.section
= sectp
;
2224 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
2226 else if (section_is_p (sectp
->name
, &names
->macinfo
))
2228 dwarf2_per_objfile
->macinfo
.s
.section
= sectp
;
2229 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
2231 else if (section_is_p (sectp
->name
, &names
->macro
))
2233 dwarf2_per_objfile
->macro
.s
.section
= sectp
;
2234 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
2236 else if (section_is_p (sectp
->name
, &names
->str
))
2238 dwarf2_per_objfile
->str
.s
.section
= sectp
;
2239 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
2241 else if (section_is_p (sectp
->name
, &names
->addr
))
2243 dwarf2_per_objfile
->addr
.s
.section
= sectp
;
2244 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
2246 else if (section_is_p (sectp
->name
, &names
->frame
))
2248 dwarf2_per_objfile
->frame
.s
.section
= sectp
;
2249 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
2251 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
2253 dwarf2_per_objfile
->eh_frame
.s
.section
= sectp
;
2254 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
2256 else if (section_is_p (sectp
->name
, &names
->ranges
))
2258 dwarf2_per_objfile
->ranges
.s
.section
= sectp
;
2259 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
2261 else if (section_is_p (sectp
->name
, &names
->types
))
2263 struct dwarf2_section_info type_section
;
2265 memset (&type_section
, 0, sizeof (type_section
));
2266 type_section
.s
.section
= sectp
;
2267 type_section
.size
= bfd_get_section_size (sectp
);
2269 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
2272 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
2274 dwarf2_per_objfile
->gdb_index
.s
.section
= sectp
;
2275 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
2278 if ((bfd_get_section_flags (abfd
, sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2279 && bfd_section_vma (abfd
, sectp
) == 0)
2280 dwarf2_per_objfile
->has_section_at_zero
= 1;
2283 /* A helper function that decides whether a section is empty,
2287 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2289 if (section
->is_virtual
)
2290 return section
->size
== 0;
2291 return section
->s
.section
== NULL
|| section
->size
== 0;
2294 /* Read the contents of the section INFO.
2295 OBJFILE is the main object file, but not necessarily the file where
2296 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2298 If the section is compressed, uncompress it before returning. */
2301 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
2305 gdb_byte
*buf
, *retbuf
;
2309 info
->buffer
= NULL
;
2312 if (dwarf2_section_empty_p (info
))
2315 sectp
= get_section_bfd_section (info
);
2317 /* If this is a virtual section we need to read in the real one first. */
2318 if (info
->is_virtual
)
2320 struct dwarf2_section_info
*containing_section
=
2321 get_containing_section (info
);
2323 gdb_assert (sectp
!= NULL
);
2324 if ((sectp
->flags
& SEC_RELOC
) != 0)
2326 error (_("Dwarf Error: DWP format V2 with relocations is not"
2327 " supported in section %s [in module %s]"),
2328 get_section_name (info
), get_section_file_name (info
));
2330 dwarf2_read_section (objfile
, containing_section
);
2331 /* Other code should have already caught virtual sections that don't
2333 gdb_assert (info
->virtual_offset
+ info
->size
2334 <= containing_section
->size
);
2335 /* If the real section is empty or there was a problem reading the
2336 section we shouldn't get here. */
2337 gdb_assert (containing_section
->buffer
!= NULL
);
2338 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2342 /* If the section has relocations, we must read it ourselves.
2343 Otherwise we attach it to the BFD. */
2344 if ((sectp
->flags
& SEC_RELOC
) == 0)
2346 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2350 buf
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2353 /* When debugging .o files, we may need to apply relocations; see
2354 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2355 We never compress sections in .o files, so we only need to
2356 try this when the section is not compressed. */
2357 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2360 info
->buffer
= retbuf
;
2364 abfd
= get_section_bfd_owner (info
);
2365 gdb_assert (abfd
!= NULL
);
2367 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2368 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2370 error (_("Dwarf Error: Can't read DWARF data"
2371 " in section %s [in module %s]"),
2372 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2376 /* A helper function that returns the size of a section in a safe way.
2377 If you are positive that the section has been read before using the
2378 size, then it is safe to refer to the dwarf2_section_info object's
2379 "size" field directly. In other cases, you must call this
2380 function, because for compressed sections the size field is not set
2381 correctly until the section has been read. */
2383 static bfd_size_type
2384 dwarf2_section_size (struct objfile
*objfile
,
2385 struct dwarf2_section_info
*info
)
2388 dwarf2_read_section (objfile
, info
);
2392 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2396 dwarf2_get_section_info (struct objfile
*objfile
,
2397 enum dwarf2_section_enum sect
,
2398 asection
**sectp
, const gdb_byte
**bufp
,
2399 bfd_size_type
*sizep
)
2401 struct dwarf2_per_objfile
*data
2402 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
2403 dwarf2_objfile_data_key
);
2404 struct dwarf2_section_info
*info
;
2406 /* We may see an objfile without any DWARF, in which case we just
2417 case DWARF2_DEBUG_FRAME
:
2418 info
= &data
->frame
;
2420 case DWARF2_EH_FRAME
:
2421 info
= &data
->eh_frame
;
2424 gdb_assert_not_reached ("unexpected section");
2427 dwarf2_read_section (objfile
, info
);
2429 *sectp
= get_section_bfd_section (info
);
2430 *bufp
= info
->buffer
;
2431 *sizep
= info
->size
;
2434 /* A helper function to find the sections for a .dwz file. */
2437 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2439 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2441 /* Note that we only support the standard ELF names, because .dwz
2442 is ELF-only (at the time of writing). */
2443 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2445 dwz_file
->abbrev
.s
.section
= sectp
;
2446 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2448 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2450 dwz_file
->info
.s
.section
= sectp
;
2451 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2453 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2455 dwz_file
->str
.s
.section
= sectp
;
2456 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2458 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2460 dwz_file
->line
.s
.section
= sectp
;
2461 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2463 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2465 dwz_file
->macro
.s
.section
= sectp
;
2466 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2468 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2470 dwz_file
->gdb_index
.s
.section
= sectp
;
2471 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2475 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2476 there is no .gnu_debugaltlink section in the file. Error if there
2477 is such a section but the file cannot be found. */
2479 static struct dwz_file
*
2480 dwarf2_get_dwz_file (void)
2484 struct cleanup
*cleanup
;
2485 const char *filename
;
2486 struct dwz_file
*result
;
2487 bfd_size_type buildid_len_arg
;
2491 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2492 return dwarf2_per_objfile
->dwz_file
;
2494 bfd_set_error (bfd_error_no_error
);
2495 data
= bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2496 &buildid_len_arg
, &buildid
);
2499 if (bfd_get_error () == bfd_error_no_error
)
2501 error (_("could not read '.gnu_debugaltlink' section: %s"),
2502 bfd_errmsg (bfd_get_error ()));
2504 cleanup
= make_cleanup (xfree
, data
);
2505 make_cleanup (xfree
, buildid
);
2507 buildid_len
= (size_t) buildid_len_arg
;
2509 filename
= (const char *) data
;
2510 if (!IS_ABSOLUTE_PATH (filename
))
2512 char *abs
= gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2515 make_cleanup (xfree
, abs
);
2516 abs
= ldirname (abs
);
2517 make_cleanup (xfree
, abs
);
2519 rel
= concat (abs
, SLASH_STRING
, filename
, (char *) NULL
);
2520 make_cleanup (xfree
, rel
);
2524 /* First try the file name given in the section. If that doesn't
2525 work, try to use the build-id instead. */
2526 dwz_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2527 if (dwz_bfd
!= NULL
)
2529 if (!build_id_verify (dwz_bfd
, buildid_len
, buildid
))
2531 gdb_bfd_unref (dwz_bfd
);
2536 if (dwz_bfd
== NULL
)
2537 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2539 if (dwz_bfd
== NULL
)
2540 error (_("could not find '.gnu_debugaltlink' file for %s"),
2541 objfile_name (dwarf2_per_objfile
->objfile
));
2543 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2545 result
->dwz_bfd
= dwz_bfd
;
2547 bfd_map_over_sections (dwz_bfd
, locate_dwz_sections
, result
);
2549 do_cleanups (cleanup
);
2551 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, dwz_bfd
);
2552 dwarf2_per_objfile
->dwz_file
= result
;
2556 /* DWARF quick_symbols_functions support. */
2558 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2559 unique line tables, so we maintain a separate table of all .debug_line
2560 derived entries to support the sharing.
2561 All the quick functions need is the list of file names. We discard the
2562 line_header when we're done and don't need to record it here. */
2563 struct quick_file_names
2565 /* The data used to construct the hash key. */
2566 struct stmt_list_hash hash
;
2568 /* The number of entries in file_names, real_names. */
2569 unsigned int num_file_names
;
2571 /* The file names from the line table, after being run through
2573 const char **file_names
;
2575 /* The file names from the line table after being run through
2576 gdb_realpath. These are computed lazily. */
2577 const char **real_names
;
2580 /* When using the index (and thus not using psymtabs), each CU has an
2581 object of this type. This is used to hold information needed by
2582 the various "quick" methods. */
2583 struct dwarf2_per_cu_quick_data
2585 /* The file table. This can be NULL if there was no file table
2586 or it's currently not read in.
2587 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2588 struct quick_file_names
*file_names
;
2590 /* The corresponding symbol table. This is NULL if symbols for this
2591 CU have not yet been read. */
2592 struct compunit_symtab
*compunit_symtab
;
2594 /* A temporary mark bit used when iterating over all CUs in
2595 expand_symtabs_matching. */
2596 unsigned int mark
: 1;
2598 /* True if we've tried to read the file table and found there isn't one.
2599 There will be no point in trying to read it again next time. */
2600 unsigned int no_file_data
: 1;
2603 /* Utility hash function for a stmt_list_hash. */
2606 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2610 if (stmt_list_hash
->dwo_unit
!= NULL
)
2611 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2612 v
+= stmt_list_hash
->line_offset
.sect_off
;
2616 /* Utility equality function for a stmt_list_hash. */
2619 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2620 const struct stmt_list_hash
*rhs
)
2622 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2624 if (lhs
->dwo_unit
!= NULL
2625 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2628 return lhs
->line_offset
.sect_off
== rhs
->line_offset
.sect_off
;
2631 /* Hash function for a quick_file_names. */
2634 hash_file_name_entry (const void *e
)
2636 const struct quick_file_names
*file_data
2637 = (const struct quick_file_names
*) e
;
2639 return hash_stmt_list_entry (&file_data
->hash
);
2642 /* Equality function for a quick_file_names. */
2645 eq_file_name_entry (const void *a
, const void *b
)
2647 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2648 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2650 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2653 /* Delete function for a quick_file_names. */
2656 delete_file_name_entry (void *e
)
2658 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2661 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2663 xfree ((void*) file_data
->file_names
[i
]);
2664 if (file_data
->real_names
)
2665 xfree ((void*) file_data
->real_names
[i
]);
2668 /* The space for the struct itself lives on objfile_obstack,
2669 so we don't free it here. */
2672 /* Create a quick_file_names hash table. */
2675 create_quick_file_names_table (unsigned int nr_initial_entries
)
2677 return htab_create_alloc (nr_initial_entries
,
2678 hash_file_name_entry
, eq_file_name_entry
,
2679 delete_file_name_entry
, xcalloc
, xfree
);
2682 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2683 have to be created afterwards. You should call age_cached_comp_units after
2684 processing PER_CU->CU. dw2_setup must have been already called. */
2687 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2689 if (per_cu
->is_debug_types
)
2690 load_full_type_unit (per_cu
);
2692 load_full_comp_unit (per_cu
, language_minimal
);
2694 if (per_cu
->cu
== NULL
)
2695 return; /* Dummy CU. */
2697 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2700 /* Read in the symbols for PER_CU. */
2703 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2705 struct cleanup
*back_to
;
2707 /* Skip type_unit_groups, reading the type units they contain
2708 is handled elsewhere. */
2709 if (IS_TYPE_UNIT_GROUP (per_cu
))
2712 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2714 if (dwarf2_per_objfile
->using_index
2715 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2716 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2718 queue_comp_unit (per_cu
, language_minimal
);
2721 /* If we just loaded a CU from a DWO, and we're working with an index
2722 that may badly handle TUs, load all the TUs in that DWO as well.
2723 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2724 if (!per_cu
->is_debug_types
2725 && per_cu
->cu
!= NULL
2726 && per_cu
->cu
->dwo_unit
!= NULL
2727 && dwarf2_per_objfile
->index_table
!= NULL
2728 && dwarf2_per_objfile
->index_table
->version
<= 7
2729 /* DWP files aren't supported yet. */
2730 && get_dwp_file () == NULL
)
2731 queue_and_load_all_dwo_tus (per_cu
);
2736 /* Age the cache, releasing compilation units that have not
2737 been used recently. */
2738 age_cached_comp_units ();
2740 do_cleanups (back_to
);
2743 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2744 the objfile from which this CU came. Returns the resulting symbol
2747 static struct compunit_symtab
*
2748 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2750 gdb_assert (dwarf2_per_objfile
->using_index
);
2751 if (!per_cu
->v
.quick
->compunit_symtab
)
2753 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2754 increment_reading_symtab ();
2755 dw2_do_instantiate_symtab (per_cu
);
2756 process_cu_includes ();
2757 do_cleanups (back_to
);
2760 return per_cu
->v
.quick
->compunit_symtab
;
2763 /* Return the CU/TU given its index.
2765 This is intended for loops like:
2767 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2768 + dwarf2_per_objfile->n_type_units); ++i)
2770 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
2776 static struct dwarf2_per_cu_data
*
2777 dw2_get_cutu (int index
)
2779 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2781 index
-= dwarf2_per_objfile
->n_comp_units
;
2782 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
2783 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
2786 return dwarf2_per_objfile
->all_comp_units
[index
];
2789 /* Return the CU given its index.
2790 This differs from dw2_get_cutu in that it's for when you know INDEX
2793 static struct dwarf2_per_cu_data
*
2794 dw2_get_cu (int index
)
2796 gdb_assert (index
>= 0 && index
< dwarf2_per_objfile
->n_comp_units
);
2798 return dwarf2_per_objfile
->all_comp_units
[index
];
2801 /* A helper for create_cus_from_index that handles a given list of
2805 create_cus_from_index_list (struct objfile
*objfile
,
2806 const gdb_byte
*cu_list
, offset_type n_elements
,
2807 struct dwarf2_section_info
*section
,
2813 for (i
= 0; i
< n_elements
; i
+= 2)
2815 struct dwarf2_per_cu_data
*the_cu
;
2816 ULONGEST offset
, length
;
2818 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2819 offset
= extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2820 length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2823 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2824 struct dwarf2_per_cu_data
);
2825 the_cu
->offset
.sect_off
= offset
;
2826 the_cu
->length
= length
;
2827 the_cu
->objfile
= objfile
;
2828 the_cu
->section
= section
;
2829 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2830 struct dwarf2_per_cu_quick_data
);
2831 the_cu
->is_dwz
= is_dwz
;
2832 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
2836 /* Read the CU list from the mapped index, and use it to create all
2837 the CU objects for this objfile. */
2840 create_cus_from_index (struct objfile
*objfile
,
2841 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2842 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2844 struct dwz_file
*dwz
;
2846 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
2847 dwarf2_per_objfile
->all_comp_units
=
2848 XOBNEWVEC (&objfile
->objfile_obstack
, struct dwarf2_per_cu_data
*,
2849 dwarf2_per_objfile
->n_comp_units
);
2851 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
2852 &dwarf2_per_objfile
->info
, 0, 0);
2854 if (dwz_elements
== 0)
2857 dwz
= dwarf2_get_dwz_file ();
2858 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
2859 cu_list_elements
/ 2);
2862 /* Create the signatured type hash table from the index. */
2865 create_signatured_type_table_from_index (struct objfile
*objfile
,
2866 struct dwarf2_section_info
*section
,
2867 const gdb_byte
*bytes
,
2868 offset_type elements
)
2871 htab_t sig_types_hash
;
2873 dwarf2_per_objfile
->n_type_units
2874 = dwarf2_per_objfile
->n_allocated_type_units
2876 dwarf2_per_objfile
->all_type_units
=
2877 XNEWVEC (struct signatured_type
*, dwarf2_per_objfile
->n_type_units
);
2879 sig_types_hash
= allocate_signatured_type_table (objfile
);
2881 for (i
= 0; i
< elements
; i
+= 3)
2883 struct signatured_type
*sig_type
;
2884 ULONGEST offset
, type_offset_in_tu
, signature
;
2887 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2888 offset
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2889 type_offset_in_tu
= extract_unsigned_integer (bytes
+ 8, 8,
2891 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2894 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2895 struct signatured_type
);
2896 sig_type
->signature
= signature
;
2897 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2898 sig_type
->per_cu
.is_debug_types
= 1;
2899 sig_type
->per_cu
.section
= section
;
2900 sig_type
->per_cu
.offset
.sect_off
= offset
;
2901 sig_type
->per_cu
.objfile
= objfile
;
2902 sig_type
->per_cu
.v
.quick
2903 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2904 struct dwarf2_per_cu_quick_data
);
2906 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2909 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
2912 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2915 /* Read the address map data from the mapped index, and use it to
2916 populate the objfile's psymtabs_addrmap. */
2919 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2921 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2922 const gdb_byte
*iter
, *end
;
2923 struct obstack temp_obstack
;
2924 struct addrmap
*mutable_map
;
2925 struct cleanup
*cleanup
;
2928 obstack_init (&temp_obstack
);
2929 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2930 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2932 iter
= index
->address_table
;
2933 end
= iter
+ index
->address_table_size
;
2935 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2939 ULONGEST hi
, lo
, cu_index
;
2940 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2942 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2944 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2949 complaint (&symfile_complaints
,
2950 _(".gdb_index address table has invalid range (%s - %s)"),
2951 hex_string (lo
), hex_string (hi
));
2955 if (cu_index
>= dwarf2_per_objfile
->n_comp_units
)
2957 complaint (&symfile_complaints
,
2958 _(".gdb_index address table has invalid CU number %u"),
2959 (unsigned) cu_index
);
2963 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
);
2964 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
);
2965 addrmap_set_empty (mutable_map
, lo
, hi
- 1, dw2_get_cutu (cu_index
));
2968 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2969 &objfile
->objfile_obstack
);
2970 do_cleanups (cleanup
);
2973 /* The hash function for strings in the mapped index. This is the same as
2974 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2975 implementation. This is necessary because the hash function is tied to the
2976 format of the mapped index file. The hash values do not have to match with
2979 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2982 mapped_index_string_hash (int index_version
, const void *p
)
2984 const unsigned char *str
= (const unsigned char *) p
;
2988 while ((c
= *str
++) != 0)
2990 if (index_version
>= 5)
2992 r
= r
* 67 + c
- 113;
2998 /* Find a slot in the mapped index INDEX for the object named NAME.
2999 If NAME is found, set *VEC_OUT to point to the CU vector in the
3000 constant pool and return 1. If NAME cannot be found, return 0. */
3003 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3004 offset_type
**vec_out
)
3006 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3008 offset_type slot
, step
;
3009 int (*cmp
) (const char *, const char *);
3011 if (current_language
->la_language
== language_cplus
3012 || current_language
->la_language
== language_fortran
3013 || current_language
->la_language
== language_d
)
3015 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3018 if (strchr (name
, '(') != NULL
)
3020 char *without_params
= cp_remove_params (name
);
3022 if (without_params
!= NULL
)
3024 make_cleanup (xfree
, without_params
);
3025 name
= without_params
;
3030 /* Index version 4 did not support case insensitive searches. But the
3031 indices for case insensitive languages are built in lowercase, therefore
3032 simulate our NAME being searched is also lowercased. */
3033 hash
= mapped_index_string_hash ((index
->version
== 4
3034 && case_sensitivity
== case_sensitive_off
3035 ? 5 : index
->version
),
3038 slot
= hash
& (index
->symbol_table_slots
- 1);
3039 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
3040 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3044 /* Convert a slot number to an offset into the table. */
3045 offset_type i
= 2 * slot
;
3047 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
3049 do_cleanups (back_to
);
3053 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
3054 if (!cmp (name
, str
))
3056 *vec_out
= (offset_type
*) (index
->constant_pool
3057 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
3058 do_cleanups (back_to
);
3062 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
3066 /* A helper function that reads the .gdb_index from SECTION and fills
3067 in MAP. FILENAME is the name of the file containing the section;
3068 it is used for error reporting. DEPRECATED_OK is nonzero if it is
3069 ok to use deprecated sections.
3071 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3072 out parameters that are filled in with information about the CU and
3073 TU lists in the section.
3075 Returns 1 if all went well, 0 otherwise. */
3078 read_index_from_section (struct objfile
*objfile
,
3079 const char *filename
,
3081 struct dwarf2_section_info
*section
,
3082 struct mapped_index
*map
,
3083 const gdb_byte
**cu_list
,
3084 offset_type
*cu_list_elements
,
3085 const gdb_byte
**types_list
,
3086 offset_type
*types_list_elements
)
3088 const gdb_byte
*addr
;
3089 offset_type version
;
3090 offset_type
*metadata
;
3093 if (dwarf2_section_empty_p (section
))
3096 /* Older elfutils strip versions could keep the section in the main
3097 executable while splitting it for the separate debug info file. */
3098 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
3101 dwarf2_read_section (objfile
, section
);
3103 addr
= section
->buffer
;
3104 /* Version check. */
3105 version
= MAYBE_SWAP (*(offset_type
*) addr
);
3106 /* Versions earlier than 3 emitted every copy of a psymbol. This
3107 causes the index to behave very poorly for certain requests. Version 3
3108 contained incomplete addrmap. So, it seems better to just ignore such
3112 static int warning_printed
= 0;
3113 if (!warning_printed
)
3115 warning (_("Skipping obsolete .gdb_index section in %s."),
3117 warning_printed
= 1;
3121 /* Index version 4 uses a different hash function than index version
3124 Versions earlier than 6 did not emit psymbols for inlined
3125 functions. Using these files will cause GDB not to be able to
3126 set breakpoints on inlined functions by name, so we ignore these
3127 indices unless the user has done
3128 "set use-deprecated-index-sections on". */
3129 if (version
< 6 && !deprecated_ok
)
3131 static int warning_printed
= 0;
3132 if (!warning_printed
)
3135 Skipping deprecated .gdb_index section in %s.\n\
3136 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3137 to use the section anyway."),
3139 warning_printed
= 1;
3143 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3144 of the TU (for symbols coming from TUs),
3145 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3146 Plus gold-generated indices can have duplicate entries for global symbols,
3147 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3148 These are just performance bugs, and we can't distinguish gdb-generated
3149 indices from gold-generated ones, so issue no warning here. */
3151 /* Indexes with higher version than the one supported by GDB may be no
3152 longer backward compatible. */
3156 map
->version
= version
;
3157 map
->total_size
= section
->size
;
3159 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3162 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3163 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3167 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3168 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3169 - MAYBE_SWAP (metadata
[i
]))
3173 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3174 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
3175 - MAYBE_SWAP (metadata
[i
]));
3178 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
3179 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
3180 - MAYBE_SWAP (metadata
[i
]))
3181 / (2 * sizeof (offset_type
)));
3184 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3190 /* Read the index file. If everything went ok, initialize the "quick"
3191 elements of all the CUs and return 1. Otherwise, return 0. */
3194 dwarf2_read_index (struct objfile
*objfile
)
3196 struct mapped_index local_map
, *map
;
3197 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3198 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3199 struct dwz_file
*dwz
;
3201 if (!read_index_from_section (objfile
, objfile_name (objfile
),
3202 use_deprecated_index_sections
,
3203 &dwarf2_per_objfile
->gdb_index
, &local_map
,
3204 &cu_list
, &cu_list_elements
,
3205 &types_list
, &types_list_elements
))
3208 /* Don't use the index if it's empty. */
3209 if (local_map
.symbol_table_slots
== 0)
3212 /* If there is a .dwz file, read it so we can get its CU list as
3214 dwz
= dwarf2_get_dwz_file ();
3217 struct mapped_index dwz_map
;
3218 const gdb_byte
*dwz_types_ignore
;
3219 offset_type dwz_types_elements_ignore
;
3221 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
3223 &dwz
->gdb_index
, &dwz_map
,
3224 &dwz_list
, &dwz_list_elements
,
3226 &dwz_types_elements_ignore
))
3228 warning (_("could not read '.gdb_index' section from %s; skipping"),
3229 bfd_get_filename (dwz
->dwz_bfd
));
3234 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
3237 if (types_list_elements
)
3239 struct dwarf2_section_info
*section
;
3241 /* We can only handle a single .debug_types when we have an
3243 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3246 section
= VEC_index (dwarf2_section_info_def
,
3247 dwarf2_per_objfile
->types
, 0);
3249 create_signatured_type_table_from_index (objfile
, section
, types_list
,
3250 types_list_elements
);
3253 create_addrmap_from_index (objfile
, &local_map
);
3255 map
= XOBNEW (&objfile
->objfile_obstack
, struct mapped_index
);
3258 dwarf2_per_objfile
->index_table
= map
;
3259 dwarf2_per_objfile
->using_index
= 1;
3260 dwarf2_per_objfile
->quick_file_names_table
=
3261 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3266 /* A helper for the "quick" functions which sets the global
3267 dwarf2_per_objfile according to OBJFILE. */
3270 dw2_setup (struct objfile
*objfile
)
3272 dwarf2_per_objfile
= ((struct dwarf2_per_objfile
*)
3273 objfile_data (objfile
, dwarf2_objfile_data_key
));
3274 gdb_assert (dwarf2_per_objfile
);
3277 /* die_reader_func for dw2_get_file_names. */
3280 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3281 const gdb_byte
*info_ptr
,
3282 struct die_info
*comp_unit_die
,
3286 struct dwarf2_cu
*cu
= reader
->cu
;
3287 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3288 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3289 struct dwarf2_per_cu_data
*lh_cu
;
3290 struct line_header
*lh
;
3291 struct attribute
*attr
;
3293 const char *name
, *comp_dir
;
3295 struct quick_file_names
*qfn
;
3296 unsigned int line_offset
;
3298 gdb_assert (! this_cu
->is_debug_types
);
3300 /* Our callers never want to match partial units -- instead they
3301 will match the enclosing full CU. */
3302 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3304 this_cu
->v
.quick
->no_file_data
= 1;
3313 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3316 struct quick_file_names find_entry
;
3318 line_offset
= DW_UNSND (attr
);
3320 /* We may have already read in this line header (TU line header sharing).
3321 If we have we're done. */
3322 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3323 find_entry
.hash
.line_offset
.sect_off
= line_offset
;
3324 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3325 &find_entry
, INSERT
);
3328 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3332 lh
= dwarf_decode_line_header (line_offset
, cu
);
3336 lh_cu
->v
.quick
->no_file_data
= 1;
3340 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3341 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3342 qfn
->hash
.line_offset
.sect_off
= line_offset
;
3343 gdb_assert (slot
!= NULL
);
3346 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
3348 qfn
->num_file_names
= lh
->num_file_names
;
3350 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, lh
->num_file_names
);
3351 for (i
= 0; i
< lh
->num_file_names
; ++i
)
3352 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
3353 qfn
->real_names
= NULL
;
3355 free_line_header (lh
);
3357 lh_cu
->v
.quick
->file_names
= qfn
;
3360 /* A helper for the "quick" functions which attempts to read the line
3361 table for THIS_CU. */
3363 static struct quick_file_names
*
3364 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3366 /* This should never be called for TUs. */
3367 gdb_assert (! this_cu
->is_debug_types
);
3368 /* Nor type unit groups. */
3369 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3371 if (this_cu
->v
.quick
->file_names
!= NULL
)
3372 return this_cu
->v
.quick
->file_names
;
3373 /* If we know there is no line data, no point in looking again. */
3374 if (this_cu
->v
.quick
->no_file_data
)
3377 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3379 if (this_cu
->v
.quick
->no_file_data
)
3381 return this_cu
->v
.quick
->file_names
;
3384 /* A helper for the "quick" functions which computes and caches the
3385 real path for a given file name from the line table. */
3388 dw2_get_real_path (struct objfile
*objfile
,
3389 struct quick_file_names
*qfn
, int index
)
3391 if (qfn
->real_names
== NULL
)
3392 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3393 qfn
->num_file_names
, const char *);
3395 if (qfn
->real_names
[index
] == NULL
)
3396 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
3398 return qfn
->real_names
[index
];
3401 static struct symtab
*
3402 dw2_find_last_source_symtab (struct objfile
*objfile
)
3404 struct compunit_symtab
*cust
;
3407 dw2_setup (objfile
);
3408 index
= dwarf2_per_objfile
->n_comp_units
- 1;
3409 cust
= dw2_instantiate_symtab (dw2_get_cutu (index
));
3412 return compunit_primary_filetab (cust
);
3415 /* Traversal function for dw2_forget_cached_source_info. */
3418 dw2_free_cached_file_names (void **slot
, void *info
)
3420 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3422 if (file_data
->real_names
)
3426 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3428 xfree ((void*) file_data
->real_names
[i
]);
3429 file_data
->real_names
[i
] = NULL
;
3437 dw2_forget_cached_source_info (struct objfile
*objfile
)
3439 dw2_setup (objfile
);
3441 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3442 dw2_free_cached_file_names
, NULL
);
3445 /* Helper function for dw2_map_symtabs_matching_filename that expands
3446 the symtabs and calls the iterator. */
3449 dw2_map_expand_apply (struct objfile
*objfile
,
3450 struct dwarf2_per_cu_data
*per_cu
,
3451 const char *name
, const char *real_path
,
3452 int (*callback
) (struct symtab
*, void *),
3455 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3457 /* Don't visit already-expanded CUs. */
3458 if (per_cu
->v
.quick
->compunit_symtab
)
3461 /* This may expand more than one symtab, and we want to iterate over
3463 dw2_instantiate_symtab (per_cu
);
3465 return iterate_over_some_symtabs (name
, real_path
, callback
, data
,
3466 objfile
->compunit_symtabs
, last_made
);
3469 /* Implementation of the map_symtabs_matching_filename method. */
3472 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
3473 const char *real_path
,
3474 int (*callback
) (struct symtab
*, void *),
3478 const char *name_basename
= lbasename (name
);
3480 dw2_setup (objfile
);
3482 /* The rule is CUs specify all the files, including those used by
3483 any TU, so there's no need to scan TUs here. */
3485 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3488 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3489 struct quick_file_names
*file_data
;
3491 /* We only need to look at symtabs not already expanded. */
3492 if (per_cu
->v
.quick
->compunit_symtab
)
3495 file_data
= dw2_get_file_names (per_cu
);
3496 if (file_data
== NULL
)
3499 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3501 const char *this_name
= file_data
->file_names
[j
];
3502 const char *this_real_name
;
3504 if (compare_filenames_for_search (this_name
, name
))
3506 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3512 /* Before we invoke realpath, which can get expensive when many
3513 files are involved, do a quick comparison of the basenames. */
3514 if (! basenames_may_differ
3515 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3518 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3519 if (compare_filenames_for_search (this_real_name
, name
))
3521 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3527 if (real_path
!= NULL
)
3529 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3530 gdb_assert (IS_ABSOLUTE_PATH (name
));
3531 if (this_real_name
!= NULL
3532 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3534 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3546 /* Struct used to manage iterating over all CUs looking for a symbol. */
3548 struct dw2_symtab_iterator
3550 /* The internalized form of .gdb_index. */
3551 struct mapped_index
*index
;
3552 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3553 int want_specific_block
;
3554 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3555 Unused if !WANT_SPECIFIC_BLOCK. */
3557 /* The kind of symbol we're looking for. */
3559 /* The list of CUs from the index entry of the symbol,
3560 or NULL if not found. */
3562 /* The next element in VEC to look at. */
3564 /* The number of elements in VEC, or zero if there is no match. */
3566 /* Have we seen a global version of the symbol?
3567 If so we can ignore all further global instances.
3568 This is to work around gold/15646, inefficient gold-generated
3573 /* Initialize the index symtab iterator ITER.
3574 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3575 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3578 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3579 struct mapped_index
*index
,
3580 int want_specific_block
,
3585 iter
->index
= index
;
3586 iter
->want_specific_block
= want_specific_block
;
3587 iter
->block_index
= block_index
;
3588 iter
->domain
= domain
;
3590 iter
->global_seen
= 0;
3592 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3593 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3601 /* Return the next matching CU or NULL if there are no more. */
3603 static struct dwarf2_per_cu_data
*
3604 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3606 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3608 offset_type cu_index_and_attrs
=
3609 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3610 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3611 struct dwarf2_per_cu_data
*per_cu
;
3612 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3613 /* This value is only valid for index versions >= 7. */
3614 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3615 gdb_index_symbol_kind symbol_kind
=
3616 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3617 /* Only check the symbol attributes if they're present.
3618 Indices prior to version 7 don't record them,
3619 and indices >= 7 may elide them for certain symbols
3620 (gold does this). */
3622 (iter
->index
->version
>= 7
3623 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3625 /* Don't crash on bad data. */
3626 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3627 + dwarf2_per_objfile
->n_type_units
))
3629 complaint (&symfile_complaints
,
3630 _(".gdb_index entry has bad CU index"
3632 objfile_name (dwarf2_per_objfile
->objfile
));
3636 per_cu
= dw2_get_cutu (cu_index
);
3638 /* Skip if already read in. */
3639 if (per_cu
->v
.quick
->compunit_symtab
)
3642 /* Check static vs global. */
3645 if (iter
->want_specific_block
3646 && want_static
!= is_static
)
3648 /* Work around gold/15646. */
3649 if (!is_static
&& iter
->global_seen
)
3652 iter
->global_seen
= 1;
3655 /* Only check the symbol's kind if it has one. */
3658 switch (iter
->domain
)
3661 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3662 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3663 /* Some types are also in VAR_DOMAIN. */
3664 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3668 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3672 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3687 static struct compunit_symtab
*
3688 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3689 const char *name
, domain_enum domain
)
3691 struct compunit_symtab
*stab_best
= NULL
;
3692 struct mapped_index
*index
;
3694 dw2_setup (objfile
);
3696 index
= dwarf2_per_objfile
->index_table
;
3698 /* index is NULL if OBJF_READNOW. */
3701 struct dw2_symtab_iterator iter
;
3702 struct dwarf2_per_cu_data
*per_cu
;
3704 dw2_symtab_iter_init (&iter
, index
, 1, block_index
, domain
, name
);
3706 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3708 struct symbol
*sym
, *with_opaque
= NULL
;
3709 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
);
3710 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3711 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3713 sym
= block_find_symbol (block
, name
, domain
,
3714 block_find_non_opaque_type_preferred
,
3717 /* Some caution must be observed with overloaded functions
3718 and methods, since the index will not contain any overload
3719 information (but NAME might contain it). */
3722 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
3724 if (with_opaque
!= NULL
3725 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
3728 /* Keep looking through other CUs. */
3736 dw2_print_stats (struct objfile
*objfile
)
3738 int i
, total
, count
;
3740 dw2_setup (objfile
);
3741 total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
3743 for (i
= 0; i
< total
; ++i
)
3745 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3747 if (!per_cu
->v
.quick
->compunit_symtab
)
3750 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3751 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3754 /* This dumps minimal information about the index.
3755 It is called via "mt print objfiles".
3756 One use is to verify .gdb_index has been loaded by the
3757 gdb.dwarf2/gdb-index.exp testcase. */
3760 dw2_dump (struct objfile
*objfile
)
3762 dw2_setup (objfile
);
3763 gdb_assert (dwarf2_per_objfile
->using_index
);
3764 printf_filtered (".gdb_index:");
3765 if (dwarf2_per_objfile
->index_table
!= NULL
)
3767 printf_filtered (" version %d\n",
3768 dwarf2_per_objfile
->index_table
->version
);
3771 printf_filtered (" faked for \"readnow\"\n");
3772 printf_filtered ("\n");
3776 dw2_relocate (struct objfile
*objfile
,
3777 const struct section_offsets
*new_offsets
,
3778 const struct section_offsets
*delta
)
3780 /* There's nothing to relocate here. */
3784 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3785 const char *func_name
)
3787 struct mapped_index
*index
;
3789 dw2_setup (objfile
);
3791 index
= dwarf2_per_objfile
->index_table
;
3793 /* index is NULL if OBJF_READNOW. */
3796 struct dw2_symtab_iterator iter
;
3797 struct dwarf2_per_cu_data
*per_cu
;
3799 /* Note: It doesn't matter what we pass for block_index here. */
3800 dw2_symtab_iter_init (&iter
, index
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
3803 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3804 dw2_instantiate_symtab (per_cu
);
3809 dw2_expand_all_symtabs (struct objfile
*objfile
)
3813 dw2_setup (objfile
);
3815 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3816 + dwarf2_per_objfile
->n_type_units
); ++i
)
3818 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3820 dw2_instantiate_symtab (per_cu
);
3825 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3826 const char *fullname
)
3830 dw2_setup (objfile
);
3832 /* We don't need to consider type units here.
3833 This is only called for examining code, e.g. expand_line_sal.
3834 There can be an order of magnitude (or more) more type units
3835 than comp units, and we avoid them if we can. */
3837 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3840 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3841 struct quick_file_names
*file_data
;
3843 /* We only need to look at symtabs not already expanded. */
3844 if (per_cu
->v
.quick
->compunit_symtab
)
3847 file_data
= dw2_get_file_names (per_cu
);
3848 if (file_data
== NULL
)
3851 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3853 const char *this_fullname
= file_data
->file_names
[j
];
3855 if (filename_cmp (this_fullname
, fullname
) == 0)
3857 dw2_instantiate_symtab (per_cu
);
3865 dw2_map_matching_symbols (struct objfile
*objfile
,
3866 const char * name
, domain_enum domain
,
3868 int (*callback
) (struct block
*,
3869 struct symbol
*, void *),
3870 void *data
, symbol_compare_ftype
*match
,
3871 symbol_compare_ftype
*ordered_compare
)
3873 /* Currently unimplemented; used for Ada. The function can be called if the
3874 current language is Ada for a non-Ada objfile using GNU index. As Ada
3875 does not look for non-Ada symbols this function should just return. */
3879 dw2_expand_symtabs_matching
3880 (struct objfile
*objfile
,
3881 expand_symtabs_file_matcher_ftype
*file_matcher
,
3882 expand_symtabs_symbol_matcher_ftype
*symbol_matcher
,
3883 expand_symtabs_exp_notify_ftype
*expansion_notify
,
3884 enum search_domain kind
,
3889 struct mapped_index
*index
;
3891 dw2_setup (objfile
);
3893 /* index_table is NULL if OBJF_READNOW. */
3894 if (!dwarf2_per_objfile
->index_table
)
3896 index
= dwarf2_per_objfile
->index_table
;
3898 if (file_matcher
!= NULL
)
3900 struct cleanup
*cleanup
;
3901 htab_t visited_found
, visited_not_found
;
3903 visited_found
= htab_create_alloc (10,
3904 htab_hash_pointer
, htab_eq_pointer
,
3905 NULL
, xcalloc
, xfree
);
3906 cleanup
= make_cleanup_htab_delete (visited_found
);
3907 visited_not_found
= htab_create_alloc (10,
3908 htab_hash_pointer
, htab_eq_pointer
,
3909 NULL
, xcalloc
, xfree
);
3910 make_cleanup_htab_delete (visited_not_found
);
3912 /* The rule is CUs specify all the files, including those used by
3913 any TU, so there's no need to scan TUs here. */
3915 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3918 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3919 struct quick_file_names
*file_data
;
3924 per_cu
->v
.quick
->mark
= 0;
3926 /* We only need to look at symtabs not already expanded. */
3927 if (per_cu
->v
.quick
->compunit_symtab
)
3930 file_data
= dw2_get_file_names (per_cu
);
3931 if (file_data
== NULL
)
3934 if (htab_find (visited_not_found
, file_data
) != NULL
)
3936 else if (htab_find (visited_found
, file_data
) != NULL
)
3938 per_cu
->v
.quick
->mark
= 1;
3942 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3944 const char *this_real_name
;
3946 if (file_matcher (file_data
->file_names
[j
], data
, 0))
3948 per_cu
->v
.quick
->mark
= 1;
3952 /* Before we invoke realpath, which can get expensive when many
3953 files are involved, do a quick comparison of the basenames. */
3954 if (!basenames_may_differ
3955 && !file_matcher (lbasename (file_data
->file_names
[j
]),
3959 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3960 if (file_matcher (this_real_name
, data
, 0))
3962 per_cu
->v
.quick
->mark
= 1;
3967 slot
= htab_find_slot (per_cu
->v
.quick
->mark
3969 : visited_not_found
,
3974 do_cleanups (cleanup
);
3977 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
3979 offset_type idx
= 2 * iter
;
3981 offset_type
*vec
, vec_len
, vec_idx
;
3982 int global_seen
= 0;
3986 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
3989 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
3991 if (! (*symbol_matcher
) (name
, data
))
3994 /* The name was matched, now expand corresponding CUs that were
3996 vec
= (offset_type
*) (index
->constant_pool
3997 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
3998 vec_len
= MAYBE_SWAP (vec
[0]);
3999 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4001 struct dwarf2_per_cu_data
*per_cu
;
4002 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4003 /* This value is only valid for index versions >= 7. */
4004 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4005 gdb_index_symbol_kind symbol_kind
=
4006 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4007 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4008 /* Only check the symbol attributes if they're present.
4009 Indices prior to version 7 don't record them,
4010 and indices >= 7 may elide them for certain symbols
4011 (gold does this). */
4013 (index
->version
>= 7
4014 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4016 /* Work around gold/15646. */
4019 if (!is_static
&& global_seen
)
4025 /* Only check the symbol's kind if it has one. */
4030 case VARIABLES_DOMAIN
:
4031 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4034 case FUNCTIONS_DOMAIN
:
4035 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4039 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4047 /* Don't crash on bad data. */
4048 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
4049 + dwarf2_per_objfile
->n_type_units
))
4051 complaint (&symfile_complaints
,
4052 _(".gdb_index entry has bad CU index"
4053 " [in module %s]"), objfile_name (objfile
));
4057 per_cu
= dw2_get_cutu (cu_index
);
4058 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4060 int symtab_was_null
=
4061 (per_cu
->v
.quick
->compunit_symtab
== NULL
);
4063 dw2_instantiate_symtab (per_cu
);
4065 if (expansion_notify
!= NULL
4067 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
4069 expansion_notify (per_cu
->v
.quick
->compunit_symtab
,
4077 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4080 static struct compunit_symtab
*
4081 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4086 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4087 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4090 if (cust
->includes
== NULL
)
4093 for (i
= 0; cust
->includes
[i
]; ++i
)
4095 struct compunit_symtab
*s
= cust
->includes
[i
];
4097 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4105 static struct compunit_symtab
*
4106 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
4107 struct bound_minimal_symbol msymbol
,
4109 struct obj_section
*section
,
4112 struct dwarf2_per_cu_data
*data
;
4113 struct compunit_symtab
*result
;
4115 dw2_setup (objfile
);
4117 if (!objfile
->psymtabs_addrmap
)
4120 data
= (struct dwarf2_per_cu_data
*) addrmap_find (objfile
->psymtabs_addrmap
,
4125 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
4126 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4127 paddress (get_objfile_arch (objfile
), pc
));
4130 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
),
4132 gdb_assert (result
!= NULL
);
4137 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4138 void *data
, int need_fullname
)
4141 struct cleanup
*cleanup
;
4142 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
4143 NULL
, xcalloc
, xfree
);
4145 cleanup
= make_cleanup_htab_delete (visited
);
4146 dw2_setup (objfile
);
4148 /* The rule is CUs specify all the files, including those used by
4149 any TU, so there's no need to scan TUs here.
4150 We can ignore file names coming from already-expanded CUs. */
4152 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4154 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4156 if (per_cu
->v
.quick
->compunit_symtab
)
4158 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
4161 *slot
= per_cu
->v
.quick
->file_names
;
4165 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4168 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4169 struct quick_file_names
*file_data
;
4172 /* We only need to look at symtabs not already expanded. */
4173 if (per_cu
->v
.quick
->compunit_symtab
)
4176 file_data
= dw2_get_file_names (per_cu
);
4177 if (file_data
== NULL
)
4180 slot
= htab_find_slot (visited
, file_data
, INSERT
);
4183 /* Already visited. */
4188 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4190 const char *this_real_name
;
4193 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
4195 this_real_name
= NULL
;
4196 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
4200 do_cleanups (cleanup
);
4204 dw2_has_symbols (struct objfile
*objfile
)
4209 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4212 dw2_find_last_source_symtab
,
4213 dw2_forget_cached_source_info
,
4214 dw2_map_symtabs_matching_filename
,
4219 dw2_expand_symtabs_for_function
,
4220 dw2_expand_all_symtabs
,
4221 dw2_expand_symtabs_with_fullname
,
4222 dw2_map_matching_symbols
,
4223 dw2_expand_symtabs_matching
,
4224 dw2_find_pc_sect_compunit_symtab
,
4225 dw2_map_symbol_filenames
4228 /* Initialize for reading DWARF for this objfile. Return 0 if this
4229 file will use psymtabs, or 1 if using the GNU index. */
4232 dwarf2_initialize_objfile (struct objfile
*objfile
)
4234 /* If we're about to read full symbols, don't bother with the
4235 indices. In this case we also don't care if some other debug
4236 format is making psymtabs, because they are all about to be
4238 if ((objfile
->flags
& OBJF_READNOW
))
4242 dwarf2_per_objfile
->using_index
= 1;
4243 create_all_comp_units (objfile
);
4244 create_all_type_units (objfile
);
4245 dwarf2_per_objfile
->quick_file_names_table
=
4246 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
4248 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
4249 + dwarf2_per_objfile
->n_type_units
); ++i
)
4251 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4253 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4254 struct dwarf2_per_cu_quick_data
);
4257 /* Return 1 so that gdb sees the "quick" functions. However,
4258 these functions will be no-ops because we will have expanded
4263 if (dwarf2_read_index (objfile
))
4271 /* Build a partial symbol table. */
4274 dwarf2_build_psymtabs (struct objfile
*objfile
)
4277 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
4279 init_psymbol_list (objfile
, 1024);
4284 /* This isn't really ideal: all the data we allocate on the
4285 objfile's obstack is still uselessly kept around. However,
4286 freeing it seems unsafe. */
4287 struct cleanup
*cleanups
= make_cleanup_discard_psymtabs (objfile
);
4289 dwarf2_build_psymtabs_hard (objfile
);
4290 discard_cleanups (cleanups
);
4292 CATCH (except
, RETURN_MASK_ERROR
)
4294 exception_print (gdb_stderr
, except
);
4299 /* Return the total length of the CU described by HEADER. */
4302 get_cu_length (const struct comp_unit_head
*header
)
4304 return header
->initial_length_size
+ header
->length
;
4307 /* Return TRUE if OFFSET is within CU_HEADER. */
4310 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
4312 sect_offset bottom
= { cu_header
->offset
.sect_off
};
4313 sect_offset top
= { cu_header
->offset
.sect_off
+ get_cu_length (cu_header
) };
4315 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
4318 /* Find the base address of the compilation unit for range lists and
4319 location lists. It will normally be specified by DW_AT_low_pc.
4320 In DWARF-3 draft 4, the base address could be overridden by
4321 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4322 compilation units with discontinuous ranges. */
4325 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
4327 struct attribute
*attr
;
4330 cu
->base_address
= 0;
4332 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
4335 cu
->base_address
= attr_value_as_address (attr
);
4340 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4343 cu
->base_address
= attr_value_as_address (attr
);
4349 /* Read in the comp unit header information from the debug_info at info_ptr.
4350 NOTE: This leaves members offset, first_die_offset to be filled in
4353 static const gdb_byte
*
4354 read_comp_unit_head (struct comp_unit_head
*cu_header
,
4355 const gdb_byte
*info_ptr
, bfd
*abfd
)
4358 unsigned int bytes_read
;
4360 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
4361 cu_header
->initial_length_size
= bytes_read
;
4362 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
4363 info_ptr
+= bytes_read
;
4364 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
4366 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
4368 info_ptr
+= bytes_read
;
4369 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
4371 signed_addr
= bfd_get_sign_extend_vma (abfd
);
4372 if (signed_addr
< 0)
4373 internal_error (__FILE__
, __LINE__
,
4374 _("read_comp_unit_head: dwarf from non elf file"));
4375 cu_header
->signed_addr_p
= signed_addr
;
4380 /* Helper function that returns the proper abbrev section for
4383 static struct dwarf2_section_info
*
4384 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
4386 struct dwarf2_section_info
*abbrev
;
4388 if (this_cu
->is_dwz
)
4389 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
4391 abbrev
= &dwarf2_per_objfile
->abbrev
;
4396 /* Subroutine of read_and_check_comp_unit_head and
4397 read_and_check_type_unit_head to simplify them.
4398 Perform various error checking on the header. */
4401 error_check_comp_unit_head (struct comp_unit_head
*header
,
4402 struct dwarf2_section_info
*section
,
4403 struct dwarf2_section_info
*abbrev_section
)
4405 const char *filename
= get_section_file_name (section
);
4407 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
4408 error (_("Dwarf Error: wrong version in compilation unit header "
4409 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
4412 if (header
->abbrev_offset
.sect_off
4413 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
4414 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4415 "(offset 0x%lx + 6) [in module %s]"),
4416 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
4419 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4420 avoid potential 32-bit overflow. */
4421 if (((unsigned long) header
->offset
.sect_off
+ get_cu_length (header
))
4423 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4424 "(offset 0x%lx + 0) [in module %s]"),
4425 (long) header
->length
, (long) header
->offset
.sect_off
,
4429 /* Read in a CU/TU header and perform some basic error checking.
4430 The contents of the header are stored in HEADER.
4431 The result is a pointer to the start of the first DIE. */
4433 static const gdb_byte
*
4434 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
4435 struct dwarf2_section_info
*section
,
4436 struct dwarf2_section_info
*abbrev_section
,
4437 const gdb_byte
*info_ptr
,
4438 int is_debug_types_section
)
4440 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4441 bfd
*abfd
= get_section_bfd_owner (section
);
4443 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4445 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4447 /* If we're reading a type unit, skip over the signature and
4448 type_offset fields. */
4449 if (is_debug_types_section
)
4450 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
4452 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4454 error_check_comp_unit_head (header
, section
, abbrev_section
);
4459 /* Read in the types comp unit header information from .debug_types entry at
4460 types_ptr. The result is a pointer to one past the end of the header. */
4462 static const gdb_byte
*
4463 read_and_check_type_unit_head (struct comp_unit_head
*header
,
4464 struct dwarf2_section_info
*section
,
4465 struct dwarf2_section_info
*abbrev_section
,
4466 const gdb_byte
*info_ptr
,
4467 ULONGEST
*signature
,
4468 cu_offset
*type_offset_in_tu
)
4470 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4471 bfd
*abfd
= get_section_bfd_owner (section
);
4473 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4475 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4477 /* If we're reading a type unit, skip over the signature and
4478 type_offset fields. */
4479 if (signature
!= NULL
)
4480 *signature
= read_8_bytes (abfd
, info_ptr
);
4482 if (type_offset_in_tu
!= NULL
)
4483 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
4484 header
->offset_size
);
4485 info_ptr
+= header
->offset_size
;
4487 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4489 error_check_comp_unit_head (header
, section
, abbrev_section
);
4494 /* Fetch the abbreviation table offset from a comp or type unit header. */
4497 read_abbrev_offset (struct dwarf2_section_info
*section
,
4500 bfd
*abfd
= get_section_bfd_owner (section
);
4501 const gdb_byte
*info_ptr
;
4502 unsigned int initial_length_size
, offset_size
;
4503 sect_offset abbrev_offset
;
4505 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
4506 info_ptr
= section
->buffer
+ offset
.sect_off
;
4507 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
4508 offset_size
= initial_length_size
== 4 ? 4 : 8;
4509 info_ptr
+= initial_length_size
+ 2 /*version*/;
4510 abbrev_offset
.sect_off
= read_offset_1 (abfd
, info_ptr
, offset_size
);
4511 return abbrev_offset
;
4514 /* Allocate a new partial symtab for file named NAME and mark this new
4515 partial symtab as being an include of PST. */
4518 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
4519 struct objfile
*objfile
)
4521 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
4523 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
4525 /* It shares objfile->objfile_obstack. */
4526 subpst
->dirname
= pst
->dirname
;
4529 subpst
->textlow
= 0;
4530 subpst
->texthigh
= 0;
4532 subpst
->dependencies
4533 = XOBNEW (&objfile
->objfile_obstack
, struct partial_symtab
*);
4534 subpst
->dependencies
[0] = pst
;
4535 subpst
->number_of_dependencies
= 1;
4537 subpst
->globals_offset
= 0;
4538 subpst
->n_global_syms
= 0;
4539 subpst
->statics_offset
= 0;
4540 subpst
->n_static_syms
= 0;
4541 subpst
->compunit_symtab
= NULL
;
4542 subpst
->read_symtab
= pst
->read_symtab
;
4545 /* No private part is necessary for include psymtabs. This property
4546 can be used to differentiate between such include psymtabs and
4547 the regular ones. */
4548 subpst
->read_symtab_private
= NULL
;
4551 /* Read the Line Number Program data and extract the list of files
4552 included by the source file represented by PST. Build an include
4553 partial symtab for each of these included files. */
4556 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
4557 struct die_info
*die
,
4558 struct partial_symtab
*pst
)
4560 struct line_header
*lh
= NULL
;
4561 struct attribute
*attr
;
4563 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
4565 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
4567 return; /* No linetable, so no includes. */
4569 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4570 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, pst
->textlow
, 1);
4572 free_line_header (lh
);
4576 hash_signatured_type (const void *item
)
4578 const struct signatured_type
*sig_type
4579 = (const struct signatured_type
*) item
;
4581 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4582 return sig_type
->signature
;
4586 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
4588 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
4589 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
4591 return lhs
->signature
== rhs
->signature
;
4594 /* Allocate a hash table for signatured types. */
4597 allocate_signatured_type_table (struct objfile
*objfile
)
4599 return htab_create_alloc_ex (41,
4600 hash_signatured_type
,
4603 &objfile
->objfile_obstack
,
4604 hashtab_obstack_allocate
,
4605 dummy_obstack_deallocate
);
4608 /* A helper function to add a signatured type CU to a table. */
4611 add_signatured_type_cu_to_table (void **slot
, void *datum
)
4613 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
4614 struct signatured_type
***datap
= (struct signatured_type
***) datum
;
4622 /* Create the hash table of all entries in the .debug_types
4623 (or .debug_types.dwo) section(s).
4624 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4625 otherwise it is NULL.
4627 The result is a pointer to the hash table or NULL if there are no types.
4629 Note: This function processes DWO files only, not DWP files. */
4632 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
4633 VEC (dwarf2_section_info_def
) *types
)
4635 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4636 htab_t types_htab
= NULL
;
4638 struct dwarf2_section_info
*section
;
4639 struct dwarf2_section_info
*abbrev_section
;
4641 if (VEC_empty (dwarf2_section_info_def
, types
))
4644 abbrev_section
= (dwo_file
!= NULL
4645 ? &dwo_file
->sections
.abbrev
4646 : &dwarf2_per_objfile
->abbrev
);
4648 if (dwarf_read_debug
)
4649 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_types%s for %s:\n",
4650 dwo_file
? ".dwo" : "",
4651 get_section_file_name (abbrev_section
));
4654 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
4658 const gdb_byte
*info_ptr
, *end_ptr
;
4660 dwarf2_read_section (objfile
, section
);
4661 info_ptr
= section
->buffer
;
4663 if (info_ptr
== NULL
)
4666 /* We can't set abfd until now because the section may be empty or
4667 not present, in which case the bfd is unknown. */
4668 abfd
= get_section_bfd_owner (section
);
4670 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4671 because we don't need to read any dies: the signature is in the
4674 end_ptr
= info_ptr
+ section
->size
;
4675 while (info_ptr
< end_ptr
)
4678 cu_offset type_offset_in_tu
;
4680 struct signatured_type
*sig_type
;
4681 struct dwo_unit
*dwo_tu
;
4683 const gdb_byte
*ptr
= info_ptr
;
4684 struct comp_unit_head header
;
4685 unsigned int length
;
4687 offset
.sect_off
= ptr
- section
->buffer
;
4689 /* We need to read the type's signature in order to build the hash
4690 table, but we don't need anything else just yet. */
4692 ptr
= read_and_check_type_unit_head (&header
, section
,
4693 abbrev_section
, ptr
,
4694 &signature
, &type_offset_in_tu
);
4696 length
= get_cu_length (&header
);
4698 /* Skip dummy type units. */
4699 if (ptr
>= info_ptr
+ length
4700 || peek_abbrev_code (abfd
, ptr
) == 0)
4706 if (types_htab
== NULL
)
4709 types_htab
= allocate_dwo_unit_table (objfile
);
4711 types_htab
= allocate_signatured_type_table (objfile
);
4717 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4719 dwo_tu
->dwo_file
= dwo_file
;
4720 dwo_tu
->signature
= signature
;
4721 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
4722 dwo_tu
->section
= section
;
4723 dwo_tu
->offset
= offset
;
4724 dwo_tu
->length
= length
;
4728 /* N.B.: type_offset is not usable if this type uses a DWO file.
4729 The real type_offset is in the DWO file. */
4731 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4732 struct signatured_type
);
4733 sig_type
->signature
= signature
;
4734 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
4735 sig_type
->per_cu
.objfile
= objfile
;
4736 sig_type
->per_cu
.is_debug_types
= 1;
4737 sig_type
->per_cu
.section
= section
;
4738 sig_type
->per_cu
.offset
= offset
;
4739 sig_type
->per_cu
.length
= length
;
4742 slot
= htab_find_slot (types_htab
,
4743 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
4745 gdb_assert (slot
!= NULL
);
4748 sect_offset dup_offset
;
4752 const struct dwo_unit
*dup_tu
4753 = (const struct dwo_unit
*) *slot
;
4755 dup_offset
= dup_tu
->offset
;
4759 const struct signatured_type
*dup_tu
4760 = (const struct signatured_type
*) *slot
;
4762 dup_offset
= dup_tu
->per_cu
.offset
;
4765 complaint (&symfile_complaints
,
4766 _("debug type entry at offset 0x%x is duplicate to"
4767 " the entry at offset 0x%x, signature %s"),
4768 offset
.sect_off
, dup_offset
.sect_off
,
4769 hex_string (signature
));
4771 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
4773 if (dwarf_read_debug
> 1)
4774 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature %s\n",
4776 hex_string (signature
));
4785 /* Create the hash table of all entries in the .debug_types section,
4786 and initialize all_type_units.
4787 The result is zero if there is an error (e.g. missing .debug_types section),
4788 otherwise non-zero. */
4791 create_all_type_units (struct objfile
*objfile
)
4794 struct signatured_type
**iter
;
4796 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
4797 if (types_htab
== NULL
)
4799 dwarf2_per_objfile
->signatured_types
= NULL
;
4803 dwarf2_per_objfile
->signatured_types
= types_htab
;
4805 dwarf2_per_objfile
->n_type_units
4806 = dwarf2_per_objfile
->n_allocated_type_units
4807 = htab_elements (types_htab
);
4808 dwarf2_per_objfile
->all_type_units
=
4809 XNEWVEC (struct signatured_type
*, dwarf2_per_objfile
->n_type_units
);
4810 iter
= &dwarf2_per_objfile
->all_type_units
[0];
4811 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
4812 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
4813 == dwarf2_per_objfile
->n_type_units
);
4818 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
4819 If SLOT is non-NULL, it is the entry to use in the hash table.
4820 Otherwise we find one. */
4822 static struct signatured_type
*
4823 add_type_unit (ULONGEST sig
, void **slot
)
4825 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4826 int n_type_units
= dwarf2_per_objfile
->n_type_units
;
4827 struct signatured_type
*sig_type
;
4829 gdb_assert (n_type_units
<= dwarf2_per_objfile
->n_allocated_type_units
);
4831 if (n_type_units
> dwarf2_per_objfile
->n_allocated_type_units
)
4833 if (dwarf2_per_objfile
->n_allocated_type_units
== 0)
4834 dwarf2_per_objfile
->n_allocated_type_units
= 1;
4835 dwarf2_per_objfile
->n_allocated_type_units
*= 2;
4836 dwarf2_per_objfile
->all_type_units
4837 = XRESIZEVEC (struct signatured_type
*,
4838 dwarf2_per_objfile
->all_type_units
,
4839 dwarf2_per_objfile
->n_allocated_type_units
);
4840 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
4842 dwarf2_per_objfile
->n_type_units
= n_type_units
;
4844 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4845 struct signatured_type
);
4846 dwarf2_per_objfile
->all_type_units
[n_type_units
- 1] = sig_type
;
4847 sig_type
->signature
= sig
;
4848 sig_type
->per_cu
.is_debug_types
= 1;
4849 if (dwarf2_per_objfile
->using_index
)
4851 sig_type
->per_cu
.v
.quick
=
4852 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4853 struct dwarf2_per_cu_quick_data
);
4858 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4861 gdb_assert (*slot
== NULL
);
4863 /* The rest of sig_type must be filled in by the caller. */
4867 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4868 Fill in SIG_ENTRY with DWO_ENTRY. */
4871 fill_in_sig_entry_from_dwo_entry (struct objfile
*objfile
,
4872 struct signatured_type
*sig_entry
,
4873 struct dwo_unit
*dwo_entry
)
4875 /* Make sure we're not clobbering something we don't expect to. */
4876 gdb_assert (! sig_entry
->per_cu
.queued
);
4877 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
4878 if (dwarf2_per_objfile
->using_index
)
4880 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
4881 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
4884 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
4885 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
4886 gdb_assert (sig_entry
->type_offset_in_section
.sect_off
== 0);
4887 gdb_assert (sig_entry
->type_unit_group
== NULL
);
4888 gdb_assert (sig_entry
->dwo_unit
== NULL
);
4890 sig_entry
->per_cu
.section
= dwo_entry
->section
;
4891 sig_entry
->per_cu
.offset
= dwo_entry
->offset
;
4892 sig_entry
->per_cu
.length
= dwo_entry
->length
;
4893 sig_entry
->per_cu
.reading_dwo_directly
= 1;
4894 sig_entry
->per_cu
.objfile
= objfile
;
4895 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
4896 sig_entry
->dwo_unit
= dwo_entry
;
4899 /* Subroutine of lookup_signatured_type.
4900 If we haven't read the TU yet, create the signatured_type data structure
4901 for a TU to be read in directly from a DWO file, bypassing the stub.
4902 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4903 using .gdb_index, then when reading a CU we want to stay in the DWO file
4904 containing that CU. Otherwise we could end up reading several other DWO
4905 files (due to comdat folding) to process the transitive closure of all the
4906 mentioned TUs, and that can be slow. The current DWO file will have every
4907 type signature that it needs.
4908 We only do this for .gdb_index because in the psymtab case we already have
4909 to read all the DWOs to build the type unit groups. */
4911 static struct signatured_type
*
4912 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4914 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4915 struct dwo_file
*dwo_file
;
4916 struct dwo_unit find_dwo_entry
, *dwo_entry
;
4917 struct signatured_type find_sig_entry
, *sig_entry
;
4920 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4922 /* If TU skeletons have been removed then we may not have read in any
4924 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4926 dwarf2_per_objfile
->signatured_types
4927 = allocate_signatured_type_table (objfile
);
4930 /* We only ever need to read in one copy of a signatured type.
4931 Use the global signatured_types array to do our own comdat-folding
4932 of types. If this is the first time we're reading this TU, and
4933 the TU has an entry in .gdb_index, replace the recorded data from
4934 .gdb_index with this TU. */
4936 find_sig_entry
.signature
= sig
;
4937 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4938 &find_sig_entry
, INSERT
);
4939 sig_entry
= (struct signatured_type
*) *slot
;
4941 /* We can get here with the TU already read, *or* in the process of being
4942 read. Don't reassign the global entry to point to this DWO if that's
4943 the case. Also note that if the TU is already being read, it may not
4944 have come from a DWO, the program may be a mix of Fission-compiled
4945 code and non-Fission-compiled code. */
4947 /* Have we already tried to read this TU?
4948 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4949 needn't exist in the global table yet). */
4950 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
4953 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4954 dwo_unit of the TU itself. */
4955 dwo_file
= cu
->dwo_unit
->dwo_file
;
4957 /* Ok, this is the first time we're reading this TU. */
4958 if (dwo_file
->tus
== NULL
)
4960 find_dwo_entry
.signature
= sig
;
4961 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_entry
);
4962 if (dwo_entry
== NULL
)
4965 /* If the global table doesn't have an entry for this TU, add one. */
4966 if (sig_entry
== NULL
)
4967 sig_entry
= add_type_unit (sig
, slot
);
4969 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4970 sig_entry
->per_cu
.tu_read
= 1;
4974 /* Subroutine of lookup_signatured_type.
4975 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4976 then try the DWP file. If the TU stub (skeleton) has been removed then
4977 it won't be in .gdb_index. */
4979 static struct signatured_type
*
4980 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4982 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4983 struct dwp_file
*dwp_file
= get_dwp_file ();
4984 struct dwo_unit
*dwo_entry
;
4985 struct signatured_type find_sig_entry
, *sig_entry
;
4988 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4989 gdb_assert (dwp_file
!= NULL
);
4991 /* If TU skeletons have been removed then we may not have read in any
4993 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4995 dwarf2_per_objfile
->signatured_types
4996 = allocate_signatured_type_table (objfile
);
4999 find_sig_entry
.signature
= sig
;
5000 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
5001 &find_sig_entry
, INSERT
);
5002 sig_entry
= (struct signatured_type
*) *slot
;
5004 /* Have we already tried to read this TU?
5005 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
5006 needn't exist in the global table yet). */
5007 if (sig_entry
!= NULL
)
5010 if (dwp_file
->tus
== NULL
)
5012 dwo_entry
= lookup_dwo_unit_in_dwp (dwp_file
, NULL
,
5013 sig
, 1 /* is_debug_types */);
5014 if (dwo_entry
== NULL
)
5017 sig_entry
= add_type_unit (sig
, slot
);
5018 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
5023 /* Lookup a signature based type for DW_FORM_ref_sig8.
5024 Returns NULL if signature SIG is not present in the table.
5025 It is up to the caller to complain about this. */
5027 static struct signatured_type
*
5028 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
5031 && dwarf2_per_objfile
->using_index
)
5033 /* We're in a DWO/DWP file, and we're using .gdb_index.
5034 These cases require special processing. */
5035 if (get_dwp_file () == NULL
)
5036 return lookup_dwo_signatured_type (cu
, sig
);
5038 return lookup_dwp_signatured_type (cu
, sig
);
5042 struct signatured_type find_entry
, *entry
;
5044 if (dwarf2_per_objfile
->signatured_types
== NULL
)
5046 find_entry
.signature
= sig
;
5047 entry
= ((struct signatured_type
*)
5048 htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
));
5053 /* Low level DIE reading support. */
5055 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
5058 init_cu_die_reader (struct die_reader_specs
*reader
,
5059 struct dwarf2_cu
*cu
,
5060 struct dwarf2_section_info
*section
,
5061 struct dwo_file
*dwo_file
)
5063 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
5064 reader
->abfd
= get_section_bfd_owner (section
);
5066 reader
->dwo_file
= dwo_file
;
5067 reader
->die_section
= section
;
5068 reader
->buffer
= section
->buffer
;
5069 reader
->buffer_end
= section
->buffer
+ section
->size
;
5070 reader
->comp_dir
= NULL
;
5073 /* Subroutine of init_cutu_and_read_dies to simplify it.
5074 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
5075 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
5078 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
5079 from it to the DIE in the DWO. If NULL we are skipping the stub.
5080 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
5081 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
5082 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
5083 STUB_COMP_DIR may be non-NULL.
5084 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
5085 are filled in with the info of the DIE from the DWO file.
5086 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
5087 provided an abbrev table to use.
5088 The result is non-zero if a valid (non-dummy) DIE was found. */
5091 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
5092 struct dwo_unit
*dwo_unit
,
5093 int abbrev_table_provided
,
5094 struct die_info
*stub_comp_unit_die
,
5095 const char *stub_comp_dir
,
5096 struct die_reader_specs
*result_reader
,
5097 const gdb_byte
**result_info_ptr
,
5098 struct die_info
**result_comp_unit_die
,
5099 int *result_has_children
)
5101 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5102 struct dwarf2_cu
*cu
= this_cu
->cu
;
5103 struct dwarf2_section_info
*section
;
5105 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5106 ULONGEST signature
; /* Or dwo_id. */
5107 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
5108 int i
,num_extra_attrs
;
5109 struct dwarf2_section_info
*dwo_abbrev_section
;
5110 struct attribute
*attr
;
5111 struct die_info
*comp_unit_die
;
5113 /* At most one of these may be provided. */
5114 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
5116 /* These attributes aren't processed until later:
5117 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
5118 DW_AT_comp_dir is used now, to find the DWO file, but it is also
5119 referenced later. However, these attributes are found in the stub
5120 which we won't have later. In order to not impose this complication
5121 on the rest of the code, we read them here and copy them to the
5130 if (stub_comp_unit_die
!= NULL
)
5132 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5134 if (! this_cu
->is_debug_types
)
5135 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
5136 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
5137 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
5138 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
5139 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
5141 /* There should be a DW_AT_addr_base attribute here (if needed).
5142 We need the value before we can process DW_FORM_GNU_addr_index. */
5144 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
5146 cu
->addr_base
= DW_UNSND (attr
);
5148 /* There should be a DW_AT_ranges_base attribute here (if needed).
5149 We need the value before we can process DW_AT_ranges. */
5150 cu
->ranges_base
= 0;
5151 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
5153 cu
->ranges_base
= DW_UNSND (attr
);
5155 else if (stub_comp_dir
!= NULL
)
5157 /* Reconstruct the comp_dir attribute to simplify the code below. */
5158 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
5159 comp_dir
->name
= DW_AT_comp_dir
;
5160 comp_dir
->form
= DW_FORM_string
;
5161 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
5162 DW_STRING (comp_dir
) = stub_comp_dir
;
5165 /* Set up for reading the DWO CU/TU. */
5166 cu
->dwo_unit
= dwo_unit
;
5167 section
= dwo_unit
->section
;
5168 dwarf2_read_section (objfile
, section
);
5169 abfd
= get_section_bfd_owner (section
);
5170 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
5171 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
5172 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
5174 if (this_cu
->is_debug_types
)
5176 ULONGEST header_signature
;
5177 cu_offset type_offset_in_tu
;
5178 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
5180 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5184 &type_offset_in_tu
);
5185 /* This is not an assert because it can be caused by bad debug info. */
5186 if (sig_type
->signature
!= header_signature
)
5188 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5189 " TU at offset 0x%x [in module %s]"),
5190 hex_string (sig_type
->signature
),
5191 hex_string (header_signature
),
5192 dwo_unit
->offset
.sect_off
,
5193 bfd_get_filename (abfd
));
5195 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5196 /* For DWOs coming from DWP files, we don't know the CU length
5197 nor the type's offset in the TU until now. */
5198 dwo_unit
->length
= get_cu_length (&cu
->header
);
5199 dwo_unit
->type_offset_in_tu
= type_offset_in_tu
;
5201 /* Establish the type offset that can be used to lookup the type.
5202 For DWO files, we don't know it until now. */
5203 sig_type
->type_offset_in_section
.sect_off
=
5204 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
5208 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5211 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5212 /* For DWOs coming from DWP files, we don't know the CU length
5214 dwo_unit
->length
= get_cu_length (&cu
->header
);
5217 /* Replace the CU's original abbrev table with the DWO's.
5218 Reminder: We can't read the abbrev table until we've read the header. */
5219 if (abbrev_table_provided
)
5221 /* Don't free the provided abbrev table, the caller of
5222 init_cutu_and_read_dies owns it. */
5223 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5224 /* Ensure the DWO abbrev table gets freed. */
5225 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5229 dwarf2_free_abbrev_table (cu
);
5230 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5231 /* Leave any existing abbrev table cleanup as is. */
5234 /* Read in the die, but leave space to copy over the attributes
5235 from the stub. This has the benefit of simplifying the rest of
5236 the code - all the work to maintain the illusion of a single
5237 DW_TAG_{compile,type}_unit DIE is done here. */
5238 num_extra_attrs
= ((stmt_list
!= NULL
)
5242 + (comp_dir
!= NULL
));
5243 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
5244 result_has_children
, num_extra_attrs
);
5246 /* Copy over the attributes from the stub to the DIE we just read in. */
5247 comp_unit_die
= *result_comp_unit_die
;
5248 i
= comp_unit_die
->num_attrs
;
5249 if (stmt_list
!= NULL
)
5250 comp_unit_die
->attrs
[i
++] = *stmt_list
;
5252 comp_unit_die
->attrs
[i
++] = *low_pc
;
5253 if (high_pc
!= NULL
)
5254 comp_unit_die
->attrs
[i
++] = *high_pc
;
5256 comp_unit_die
->attrs
[i
++] = *ranges
;
5257 if (comp_dir
!= NULL
)
5258 comp_unit_die
->attrs
[i
++] = *comp_dir
;
5259 comp_unit_die
->num_attrs
+= num_extra_attrs
;
5261 if (dwarf_die_debug
)
5263 fprintf_unfiltered (gdb_stdlog
,
5264 "Read die from %s@0x%x of %s:\n",
5265 get_section_name (section
),
5266 (unsigned) (begin_info_ptr
- section
->buffer
),
5267 bfd_get_filename (abfd
));
5268 dump_die (comp_unit_die
, dwarf_die_debug
);
5271 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5272 TUs by skipping the stub and going directly to the entry in the DWO file.
5273 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5274 to get it via circuitous means. Blech. */
5275 if (comp_dir
!= NULL
)
5276 result_reader
->comp_dir
= DW_STRING (comp_dir
);
5278 /* Skip dummy compilation units. */
5279 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
5280 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5283 *result_info_ptr
= info_ptr
;
5287 /* Subroutine of init_cutu_and_read_dies to simplify it.
5288 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5289 Returns NULL if the specified DWO unit cannot be found. */
5291 static struct dwo_unit
*
5292 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
5293 struct die_info
*comp_unit_die
)
5295 struct dwarf2_cu
*cu
= this_cu
->cu
;
5296 struct attribute
*attr
;
5298 struct dwo_unit
*dwo_unit
;
5299 const char *comp_dir
, *dwo_name
;
5301 gdb_assert (cu
!= NULL
);
5303 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5304 dwo_name
= dwarf2_string_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5305 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5307 if (this_cu
->is_debug_types
)
5309 struct signatured_type
*sig_type
;
5311 /* Since this_cu is the first member of struct signatured_type,
5312 we can go from a pointer to one to a pointer to the other. */
5313 sig_type
= (struct signatured_type
*) this_cu
;
5314 signature
= sig_type
->signature
;
5315 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
5319 struct attribute
*attr
;
5321 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
5323 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5325 dwo_name
, objfile_name (this_cu
->objfile
));
5326 signature
= DW_UNSND (attr
);
5327 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
5334 /* Subroutine of init_cutu_and_read_dies to simplify it.
5335 See it for a description of the parameters.
5336 Read a TU directly from a DWO file, bypassing the stub.
5338 Note: This function could be a little bit simpler if we shared cleanups
5339 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
5340 to do, so we keep this function self-contained. Or we could move this
5341 into our caller, but it's complex enough already. */
5344 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
5345 int use_existing_cu
, int keep
,
5346 die_reader_func_ftype
*die_reader_func
,
5349 struct dwarf2_cu
*cu
;
5350 struct signatured_type
*sig_type
;
5351 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5352 struct die_reader_specs reader
;
5353 const gdb_byte
*info_ptr
;
5354 struct die_info
*comp_unit_die
;
5357 /* Verify we can do the following downcast, and that we have the
5359 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
5360 sig_type
= (struct signatured_type
*) this_cu
;
5361 gdb_assert (sig_type
->dwo_unit
!= NULL
);
5363 cleanups
= make_cleanup (null_cleanup
, NULL
);
5365 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5367 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
5369 /* There's no need to do the rereading_dwo_cu handling that
5370 init_cutu_and_read_dies does since we don't read the stub. */
5374 /* If !use_existing_cu, this_cu->cu must be NULL. */
5375 gdb_assert (this_cu
->cu
== NULL
);
5376 cu
= XNEW (struct dwarf2_cu
);
5377 init_one_comp_unit (cu
, this_cu
);
5378 /* If an error occurs while loading, release our storage. */
5379 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5382 /* A future optimization, if needed, would be to use an existing
5383 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
5384 could share abbrev tables. */
5386 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
5387 0 /* abbrev_table_provided */,
5388 NULL
/* stub_comp_unit_die */,
5389 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
5391 &comp_unit_die
, &has_children
) == 0)
5394 do_cleanups (cleanups
);
5398 /* All the "real" work is done here. */
5399 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5401 /* This duplicates the code in init_cutu_and_read_dies,
5402 but the alternative is making the latter more complex.
5403 This function is only for the special case of using DWO files directly:
5404 no point in overly complicating the general case just to handle this. */
5405 if (free_cu_cleanup
!= NULL
)
5409 /* We've successfully allocated this compilation unit. Let our
5410 caller clean it up when finished with it. */
5411 discard_cleanups (free_cu_cleanup
);
5413 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5414 So we have to manually free the abbrev table. */
5415 dwarf2_free_abbrev_table (cu
);
5417 /* Link this CU into read_in_chain. */
5418 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5419 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5422 do_cleanups (free_cu_cleanup
);
5425 do_cleanups (cleanups
);
5428 /* Initialize a CU (or TU) and read its DIEs.
5429 If the CU defers to a DWO file, read the DWO file as well.
5431 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5432 Otherwise the table specified in the comp unit header is read in and used.
5433 This is an optimization for when we already have the abbrev table.
5435 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5436 Otherwise, a new CU is allocated with xmalloc.
5438 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5439 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5441 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5442 linker) then DIE_READER_FUNC will not get called. */
5445 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
5446 struct abbrev_table
*abbrev_table
,
5447 int use_existing_cu
, int keep
,
5448 die_reader_func_ftype
*die_reader_func
,
5451 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5452 struct dwarf2_section_info
*section
= this_cu
->section
;
5453 bfd
*abfd
= get_section_bfd_owner (section
);
5454 struct dwarf2_cu
*cu
;
5455 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5456 struct die_reader_specs reader
;
5457 struct die_info
*comp_unit_die
;
5459 struct attribute
*attr
;
5460 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5461 struct signatured_type
*sig_type
= NULL
;
5462 struct dwarf2_section_info
*abbrev_section
;
5463 /* Non-zero if CU currently points to a DWO file and we need to
5464 reread it. When this happens we need to reread the skeleton die
5465 before we can reread the DWO file (this only applies to CUs, not TUs). */
5466 int rereading_dwo_cu
= 0;
5468 if (dwarf_die_debug
)
5469 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5470 this_cu
->is_debug_types
? "type" : "comp",
5471 this_cu
->offset
.sect_off
);
5473 if (use_existing_cu
)
5476 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5477 file (instead of going through the stub), short-circuit all of this. */
5478 if (this_cu
->reading_dwo_directly
)
5480 /* Narrow down the scope of possibilities to have to understand. */
5481 gdb_assert (this_cu
->is_debug_types
);
5482 gdb_assert (abbrev_table
== NULL
);
5483 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
5484 die_reader_func
, data
);
5488 cleanups
= make_cleanup (null_cleanup
, NULL
);
5490 /* This is cheap if the section is already read in. */
5491 dwarf2_read_section (objfile
, section
);
5493 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5495 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
5497 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5500 /* If this CU is from a DWO file we need to start over, we need to
5501 refetch the attributes from the skeleton CU.
5502 This could be optimized by retrieving those attributes from when we
5503 were here the first time: the previous comp_unit_die was stored in
5504 comp_unit_obstack. But there's no data yet that we need this
5506 if (cu
->dwo_unit
!= NULL
)
5507 rereading_dwo_cu
= 1;
5511 /* If !use_existing_cu, this_cu->cu must be NULL. */
5512 gdb_assert (this_cu
->cu
== NULL
);
5513 cu
= XNEW (struct dwarf2_cu
);
5514 init_one_comp_unit (cu
, this_cu
);
5515 /* If an error occurs while loading, release our storage. */
5516 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5519 /* Get the header. */
5520 if (cu
->header
.first_die_offset
.cu_off
!= 0 && ! rereading_dwo_cu
)
5522 /* We already have the header, there's no need to read it in again. */
5523 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
5527 if (this_cu
->is_debug_types
)
5530 cu_offset type_offset_in_tu
;
5532 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5533 abbrev_section
, info_ptr
,
5535 &type_offset_in_tu
);
5537 /* Since per_cu is the first member of struct signatured_type,
5538 we can go from a pointer to one to a pointer to the other. */
5539 sig_type
= (struct signatured_type
*) this_cu
;
5540 gdb_assert (sig_type
->signature
== signature
);
5541 gdb_assert (sig_type
->type_offset_in_tu
.cu_off
5542 == type_offset_in_tu
.cu_off
);
5543 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5545 /* LENGTH has not been set yet for type units if we're
5546 using .gdb_index. */
5547 this_cu
->length
= get_cu_length (&cu
->header
);
5549 /* Establish the type offset that can be used to lookup the type. */
5550 sig_type
->type_offset_in_section
.sect_off
=
5551 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
5555 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5559 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5560 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
5564 /* Skip dummy compilation units. */
5565 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5566 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5568 do_cleanups (cleanups
);
5572 /* If we don't have them yet, read the abbrevs for this compilation unit.
5573 And if we need to read them now, make sure they're freed when we're
5574 done. Note that it's important that if the CU had an abbrev table
5575 on entry we don't free it when we're done: Somewhere up the call stack
5576 it may be in use. */
5577 if (abbrev_table
!= NULL
)
5579 gdb_assert (cu
->abbrev_table
== NULL
);
5580 gdb_assert (cu
->header
.abbrev_offset
.sect_off
5581 == abbrev_table
->offset
.sect_off
);
5582 cu
->abbrev_table
= abbrev_table
;
5584 else if (cu
->abbrev_table
== NULL
)
5586 dwarf2_read_abbrevs (cu
, abbrev_section
);
5587 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5589 else if (rereading_dwo_cu
)
5591 dwarf2_free_abbrev_table (cu
);
5592 dwarf2_read_abbrevs (cu
, abbrev_section
);
5595 /* Read the top level CU/TU die. */
5596 init_cu_die_reader (&reader
, cu
, section
, NULL
);
5597 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5599 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5601 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5602 DWO CU, that this test will fail (the attribute will not be present). */
5603 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5606 struct dwo_unit
*dwo_unit
;
5607 struct die_info
*dwo_comp_unit_die
;
5611 complaint (&symfile_complaints
,
5612 _("compilation unit with DW_AT_GNU_dwo_name"
5613 " has children (offset 0x%x) [in module %s]"),
5614 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
5616 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
5617 if (dwo_unit
!= NULL
)
5619 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
5620 abbrev_table
!= NULL
,
5621 comp_unit_die
, NULL
,
5623 &dwo_comp_unit_die
, &has_children
) == 0)
5626 do_cleanups (cleanups
);
5629 comp_unit_die
= dwo_comp_unit_die
;
5633 /* Yikes, we couldn't find the rest of the DIE, we only have
5634 the stub. A complaint has already been logged. There's
5635 not much more we can do except pass on the stub DIE to
5636 die_reader_func. We don't want to throw an error on bad
5641 /* All of the above is setup for this call. Yikes. */
5642 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5644 /* Done, clean up. */
5645 if (free_cu_cleanup
!= NULL
)
5649 /* We've successfully allocated this compilation unit. Let our
5650 caller clean it up when finished with it. */
5651 discard_cleanups (free_cu_cleanup
);
5653 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5654 So we have to manually free the abbrev table. */
5655 dwarf2_free_abbrev_table (cu
);
5657 /* Link this CU into read_in_chain. */
5658 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5659 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5662 do_cleanups (free_cu_cleanup
);
5665 do_cleanups (cleanups
);
5668 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5669 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5670 to have already done the lookup to find the DWO file).
5672 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5673 THIS_CU->is_debug_types, but nothing else.
5675 We fill in THIS_CU->length.
5677 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5678 linker) then DIE_READER_FUNC will not get called.
5680 THIS_CU->cu is always freed when done.
5681 This is done in order to not leave THIS_CU->cu in a state where we have
5682 to care whether it refers to the "main" CU or the DWO CU. */
5685 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
5686 struct dwo_file
*dwo_file
,
5687 die_reader_func_ftype
*die_reader_func
,
5690 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5691 struct dwarf2_section_info
*section
= this_cu
->section
;
5692 bfd
*abfd
= get_section_bfd_owner (section
);
5693 struct dwarf2_section_info
*abbrev_section
;
5694 struct dwarf2_cu cu
;
5695 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5696 struct die_reader_specs reader
;
5697 struct cleanup
*cleanups
;
5698 struct die_info
*comp_unit_die
;
5701 if (dwarf_die_debug
)
5702 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5703 this_cu
->is_debug_types
? "type" : "comp",
5704 this_cu
->offset
.sect_off
);
5706 gdb_assert (this_cu
->cu
== NULL
);
5708 abbrev_section
= (dwo_file
!= NULL
5709 ? &dwo_file
->sections
.abbrev
5710 : get_abbrev_section_for_cu (this_cu
));
5712 /* This is cheap if the section is already read in. */
5713 dwarf2_read_section (objfile
, section
);
5715 init_one_comp_unit (&cu
, this_cu
);
5717 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
5719 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5720 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
5721 abbrev_section
, info_ptr
,
5722 this_cu
->is_debug_types
);
5724 this_cu
->length
= get_cu_length (&cu
.header
);
5726 /* Skip dummy compilation units. */
5727 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5728 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5730 do_cleanups (cleanups
);
5734 dwarf2_read_abbrevs (&cu
, abbrev_section
);
5735 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
5737 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
5738 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5740 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5742 do_cleanups (cleanups
);
5745 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5746 does not lookup the specified DWO file.
5747 This cannot be used to read DWO files.
5749 THIS_CU->cu is always freed when done.
5750 This is done in order to not leave THIS_CU->cu in a state where we have
5751 to care whether it refers to the "main" CU or the DWO CU.
5752 We can revisit this if the data shows there's a performance issue. */
5755 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
5756 die_reader_func_ftype
*die_reader_func
,
5759 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
5762 /* Type Unit Groups.
5764 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5765 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5766 so that all types coming from the same compilation (.o file) are grouped
5767 together. A future step could be to put the types in the same symtab as
5768 the CU the types ultimately came from. */
5771 hash_type_unit_group (const void *item
)
5773 const struct type_unit_group
*tu_group
5774 = (const struct type_unit_group
*) item
;
5776 return hash_stmt_list_entry (&tu_group
->hash
);
5780 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
5782 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
5783 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
5785 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
5788 /* Allocate a hash table for type unit groups. */
5791 allocate_type_unit_groups_table (void)
5793 return htab_create_alloc_ex (3,
5794 hash_type_unit_group
,
5797 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
5798 hashtab_obstack_allocate
,
5799 dummy_obstack_deallocate
);
5802 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5803 partial symtabs. We combine several TUs per psymtab to not let the size
5804 of any one psymtab grow too big. */
5805 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5806 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5808 /* Helper routine for get_type_unit_group.
5809 Create the type_unit_group object used to hold one or more TUs. */
5811 static struct type_unit_group
*
5812 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
5814 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5815 struct dwarf2_per_cu_data
*per_cu
;
5816 struct type_unit_group
*tu_group
;
5818 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5819 struct type_unit_group
);
5820 per_cu
= &tu_group
->per_cu
;
5821 per_cu
->objfile
= objfile
;
5823 if (dwarf2_per_objfile
->using_index
)
5825 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5826 struct dwarf2_per_cu_quick_data
);
5830 unsigned int line_offset
= line_offset_struct
.sect_off
;
5831 struct partial_symtab
*pst
;
5834 /* Give the symtab a useful name for debug purposes. */
5835 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
5836 name
= xstrprintf ("<type_units_%d>",
5837 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
5839 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
5841 pst
= create_partial_symtab (per_cu
, name
);
5847 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
5848 tu_group
->hash
.line_offset
= line_offset_struct
;
5853 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5854 STMT_LIST is a DW_AT_stmt_list attribute. */
5856 static struct type_unit_group
*
5857 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
5859 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5860 struct type_unit_group
*tu_group
;
5862 unsigned int line_offset
;
5863 struct type_unit_group type_unit_group_for_lookup
;
5865 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
5867 dwarf2_per_objfile
->type_unit_groups
=
5868 allocate_type_unit_groups_table ();
5871 /* Do we need to create a new group, or can we use an existing one? */
5875 line_offset
= DW_UNSND (stmt_list
);
5876 ++tu_stats
->nr_symtab_sharers
;
5880 /* Ugh, no stmt_list. Rare, but we have to handle it.
5881 We can do various things here like create one group per TU or
5882 spread them over multiple groups to split up the expansion work.
5883 To avoid worst case scenarios (too many groups or too large groups)
5884 we, umm, group them in bunches. */
5885 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5886 | (tu_stats
->nr_stmt_less_type_units
5887 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
5888 ++tu_stats
->nr_stmt_less_type_units
;
5891 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
5892 type_unit_group_for_lookup
.hash
.line_offset
.sect_off
= line_offset
;
5893 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
5894 &type_unit_group_for_lookup
, INSERT
);
5897 tu_group
= (struct type_unit_group
*) *slot
;
5898 gdb_assert (tu_group
!= NULL
);
5902 sect_offset line_offset_struct
;
5904 line_offset_struct
.sect_off
= line_offset
;
5905 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
5907 ++tu_stats
->nr_symtabs
;
5913 /* Partial symbol tables. */
5915 /* Create a psymtab named NAME and assign it to PER_CU.
5917 The caller must fill in the following details:
5918 dirname, textlow, texthigh. */
5920 static struct partial_symtab
*
5921 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
5923 struct objfile
*objfile
= per_cu
->objfile
;
5924 struct partial_symtab
*pst
;
5926 pst
= start_psymtab_common (objfile
, name
, 0,
5927 objfile
->global_psymbols
.next
,
5928 objfile
->static_psymbols
.next
);
5930 pst
->psymtabs_addrmap_supported
= 1;
5932 /* This is the glue that links PST into GDB's symbol API. */
5933 pst
->read_symtab_private
= per_cu
;
5934 pst
->read_symtab
= dwarf2_read_symtab
;
5935 per_cu
->v
.psymtab
= pst
;
5940 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5943 struct process_psymtab_comp_unit_data
5945 /* True if we are reading a DW_TAG_partial_unit. */
5947 int want_partial_unit
;
5949 /* The "pretend" language that is used if the CU doesn't declare a
5952 enum language pretend_language
;
5955 /* die_reader_func for process_psymtab_comp_unit. */
5958 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
5959 const gdb_byte
*info_ptr
,
5960 struct die_info
*comp_unit_die
,
5964 struct dwarf2_cu
*cu
= reader
->cu
;
5965 struct objfile
*objfile
= cu
->objfile
;
5966 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5967 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
5969 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
5970 struct partial_symtab
*pst
;
5971 enum pc_bounds_kind cu_bounds_kind
;
5972 const char *filename
;
5973 struct process_psymtab_comp_unit_data
*info
5974 = (struct process_psymtab_comp_unit_data
*) data
;
5976 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
5979 gdb_assert (! per_cu
->is_debug_types
);
5981 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
5983 cu
->list_in_scope
= &file_symbols
;
5985 /* Allocate a new partial symbol table structure. */
5986 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
5987 if (filename
== NULL
)
5990 pst
= create_partial_symtab (per_cu
, filename
);
5992 /* This must be done before calling dwarf2_build_include_psymtabs. */
5993 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5995 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5997 dwarf2_find_base_address (comp_unit_die
, cu
);
5999 /* Possibly set the default values of LOWPC and HIGHPC from
6001 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
6002 &best_highpc
, cu
, pst
);
6003 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
6004 /* Store the contiguous range if it is not empty; it can be empty for
6005 CUs with no code. */
6006 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6007 gdbarch_adjust_dwarf2_addr (gdbarch
,
6008 best_lowpc
+ baseaddr
),
6009 gdbarch_adjust_dwarf2_addr (gdbarch
,
6010 best_highpc
+ baseaddr
) - 1,
6013 /* Check if comp unit has_children.
6014 If so, read the rest of the partial symbols from this comp unit.
6015 If not, there's no more debug_info for this comp unit. */
6018 struct partial_die_info
*first_die
;
6019 CORE_ADDR lowpc
, highpc
;
6021 lowpc
= ((CORE_ADDR
) -1);
6022 highpc
= ((CORE_ADDR
) 0);
6024 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6026 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
6027 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
6029 /* If we didn't find a lowpc, set it to highpc to avoid
6030 complaints from `maint check'. */
6031 if (lowpc
== ((CORE_ADDR
) -1))
6034 /* If the compilation unit didn't have an explicit address range,
6035 then use the information extracted from its child dies. */
6036 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
6039 best_highpc
= highpc
;
6042 pst
->textlow
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
);
6043 pst
->texthigh
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
);
6045 end_psymtab_common (objfile
, pst
);
6047 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
6050 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6051 struct dwarf2_per_cu_data
*iter
;
6053 /* Fill in 'dependencies' here; we fill in 'users' in a
6055 pst
->number_of_dependencies
= len
;
6057 XOBNEWVEC (&objfile
->objfile_obstack
, struct partial_symtab
*, len
);
6059 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
6062 pst
->dependencies
[i
] = iter
->v
.psymtab
;
6064 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6067 /* Get the list of files included in the current compilation unit,
6068 and build a psymtab for each of them. */
6069 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
6071 if (dwarf_read_debug
)
6073 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6075 fprintf_unfiltered (gdb_stdlog
,
6076 "Psymtab for %s unit @0x%x: %s - %s"
6077 ", %d global, %d static syms\n",
6078 per_cu
->is_debug_types
? "type" : "comp",
6079 per_cu
->offset
.sect_off
,
6080 paddress (gdbarch
, pst
->textlow
),
6081 paddress (gdbarch
, pst
->texthigh
),
6082 pst
->n_global_syms
, pst
->n_static_syms
);
6086 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6087 Process compilation unit THIS_CU for a psymtab. */
6090 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
6091 int want_partial_unit
,
6092 enum language pretend_language
)
6094 struct process_psymtab_comp_unit_data info
;
6096 /* If this compilation unit was already read in, free the
6097 cached copy in order to read it in again. This is
6098 necessary because we skipped some symbols when we first
6099 read in the compilation unit (see load_partial_dies).
6100 This problem could be avoided, but the benefit is unclear. */
6101 if (this_cu
->cu
!= NULL
)
6102 free_one_cached_comp_unit (this_cu
);
6104 gdb_assert (! this_cu
->is_debug_types
);
6105 info
.want_partial_unit
= want_partial_unit
;
6106 info
.pretend_language
= pretend_language
;
6107 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
6108 process_psymtab_comp_unit_reader
,
6111 /* Age out any secondary CUs. */
6112 age_cached_comp_units ();
6115 /* Reader function for build_type_psymtabs. */
6118 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
6119 const gdb_byte
*info_ptr
,
6120 struct die_info
*type_unit_die
,
6124 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6125 struct dwarf2_cu
*cu
= reader
->cu
;
6126 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6127 struct signatured_type
*sig_type
;
6128 struct type_unit_group
*tu_group
;
6129 struct attribute
*attr
;
6130 struct partial_die_info
*first_die
;
6131 CORE_ADDR lowpc
, highpc
;
6132 struct partial_symtab
*pst
;
6134 gdb_assert (data
== NULL
);
6135 gdb_assert (per_cu
->is_debug_types
);
6136 sig_type
= (struct signatured_type
*) per_cu
;
6141 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
6142 tu_group
= get_type_unit_group (cu
, attr
);
6144 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
6146 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
6147 cu
->list_in_scope
= &file_symbols
;
6148 pst
= create_partial_symtab (per_cu
, "");
6151 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6153 lowpc
= (CORE_ADDR
) -1;
6154 highpc
= (CORE_ADDR
) 0;
6155 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
6157 end_psymtab_common (objfile
, pst
);
6160 /* Struct used to sort TUs by their abbreviation table offset. */
6162 struct tu_abbrev_offset
6164 struct signatured_type
*sig_type
;
6165 sect_offset abbrev_offset
;
6168 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
6171 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
6173 const struct tu_abbrev_offset
* const *a
6174 = (const struct tu_abbrev_offset
* const*) ap
;
6175 const struct tu_abbrev_offset
* const *b
6176 = (const struct tu_abbrev_offset
* const*) bp
;
6177 unsigned int aoff
= (*a
)->abbrev_offset
.sect_off
;
6178 unsigned int boff
= (*b
)->abbrev_offset
.sect_off
;
6180 return (aoff
> boff
) - (aoff
< boff
);
6183 /* Efficiently read all the type units.
6184 This does the bulk of the work for build_type_psymtabs.
6186 The efficiency is because we sort TUs by the abbrev table they use and
6187 only read each abbrev table once. In one program there are 200K TUs
6188 sharing 8K abbrev tables.
6190 The main purpose of this function is to support building the
6191 dwarf2_per_objfile->type_unit_groups table.
6192 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
6193 can collapse the search space by grouping them by stmt_list.
6194 The savings can be significant, in the same program from above the 200K TUs
6195 share 8K stmt_list tables.
6197 FUNC is expected to call get_type_unit_group, which will create the
6198 struct type_unit_group if necessary and add it to
6199 dwarf2_per_objfile->type_unit_groups. */
6202 build_type_psymtabs_1 (void)
6204 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6205 struct cleanup
*cleanups
;
6206 struct abbrev_table
*abbrev_table
;
6207 sect_offset abbrev_offset
;
6208 struct tu_abbrev_offset
*sorted_by_abbrev
;
6211 /* It's up to the caller to not call us multiple times. */
6212 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
6214 if (dwarf2_per_objfile
->n_type_units
== 0)
6217 /* TUs typically share abbrev tables, and there can be way more TUs than
6218 abbrev tables. Sort by abbrev table to reduce the number of times we
6219 read each abbrev table in.
6220 Alternatives are to punt or to maintain a cache of abbrev tables.
6221 This is simpler and efficient enough for now.
6223 Later we group TUs by their DW_AT_stmt_list value (as this defines the
6224 symtab to use). Typically TUs with the same abbrev offset have the same
6225 stmt_list value too so in practice this should work well.
6227 The basic algorithm here is:
6229 sort TUs by abbrev table
6230 for each TU with same abbrev table:
6231 read abbrev table if first user
6232 read TU top level DIE
6233 [IWBN if DWO skeletons had DW_AT_stmt_list]
6236 if (dwarf_read_debug
)
6237 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
6239 /* Sort in a separate table to maintain the order of all_type_units
6240 for .gdb_index: TU indices directly index all_type_units. */
6241 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
6242 dwarf2_per_objfile
->n_type_units
);
6243 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6245 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
6247 sorted_by_abbrev
[i
].sig_type
= sig_type
;
6248 sorted_by_abbrev
[i
].abbrev_offset
=
6249 read_abbrev_offset (sig_type
->per_cu
.section
,
6250 sig_type
->per_cu
.offset
);
6252 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
6253 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
6254 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
6256 abbrev_offset
.sect_off
= ~(unsigned) 0;
6257 abbrev_table
= NULL
;
6258 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
6260 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6262 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
6264 /* Switch to the next abbrev table if necessary. */
6265 if (abbrev_table
== NULL
6266 || tu
->abbrev_offset
.sect_off
!= abbrev_offset
.sect_off
)
6268 if (abbrev_table
!= NULL
)
6270 abbrev_table_free (abbrev_table
);
6271 /* Reset to NULL in case abbrev_table_read_table throws
6272 an error: abbrev_table_free_cleanup will get called. */
6273 abbrev_table
= NULL
;
6275 abbrev_offset
= tu
->abbrev_offset
;
6277 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
6279 ++tu_stats
->nr_uniq_abbrev_tables
;
6282 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
6283 build_type_psymtabs_reader
, NULL
);
6286 do_cleanups (cleanups
);
6289 /* Print collected type unit statistics. */
6292 print_tu_stats (void)
6294 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6296 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
6297 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
6298 dwarf2_per_objfile
->n_type_units
);
6299 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
6300 tu_stats
->nr_uniq_abbrev_tables
);
6301 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
6302 tu_stats
->nr_symtabs
);
6303 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
6304 tu_stats
->nr_symtab_sharers
);
6305 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
6306 tu_stats
->nr_stmt_less_type_units
);
6307 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
6308 tu_stats
->nr_all_type_units_reallocs
);
6311 /* Traversal function for build_type_psymtabs. */
6314 build_type_psymtab_dependencies (void **slot
, void *info
)
6316 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6317 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
6318 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
6319 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6320 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
6321 struct signatured_type
*iter
;
6324 gdb_assert (len
> 0);
6325 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
6327 pst
->number_of_dependencies
= len
;
6329 XOBNEWVEC (&objfile
->objfile_obstack
, struct partial_symtab
*, len
);
6331 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
6334 gdb_assert (iter
->per_cu
.is_debug_types
);
6335 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
6336 iter
->type_unit_group
= tu_group
;
6339 VEC_free (sig_type_ptr
, tu_group
->tus
);
6344 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6345 Build partial symbol tables for the .debug_types comp-units. */
6348 build_type_psymtabs (struct objfile
*objfile
)
6350 if (! create_all_type_units (objfile
))
6353 build_type_psymtabs_1 ();
6356 /* Traversal function for process_skeletonless_type_unit.
6357 Read a TU in a DWO file and build partial symbols for it. */
6360 process_skeletonless_type_unit (void **slot
, void *info
)
6362 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
6363 struct objfile
*objfile
= (struct objfile
*) info
;
6364 struct signatured_type find_entry
, *entry
;
6366 /* If this TU doesn't exist in the global table, add it and read it in. */
6368 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6370 dwarf2_per_objfile
->signatured_types
6371 = allocate_signatured_type_table (objfile
);
6374 find_entry
.signature
= dwo_unit
->signature
;
6375 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
6377 /* If we've already seen this type there's nothing to do. What's happening
6378 is we're doing our own version of comdat-folding here. */
6382 /* This does the job that create_all_type_units would have done for
6384 entry
= add_type_unit (dwo_unit
->signature
, slot
);
6385 fill_in_sig_entry_from_dwo_entry (objfile
, entry
, dwo_unit
);
6388 /* This does the job that build_type_psymtabs_1 would have done. */
6389 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0,
6390 build_type_psymtabs_reader
, NULL
);
6395 /* Traversal function for process_skeletonless_type_units. */
6398 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
6400 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
6402 if (dwo_file
->tus
!= NULL
)
6404 htab_traverse_noresize (dwo_file
->tus
,
6405 process_skeletonless_type_unit
, info
);
6411 /* Scan all TUs of DWO files, verifying we've processed them.
6412 This is needed in case a TU was emitted without its skeleton.
6413 Note: This can't be done until we know what all the DWO files are. */
6416 process_skeletonless_type_units (struct objfile
*objfile
)
6418 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
6419 if (get_dwp_file () == NULL
6420 && dwarf2_per_objfile
->dwo_files
!= NULL
)
6422 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
,
6423 process_dwo_file_for_skeletonless_type_units
,
6428 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6431 psymtabs_addrmap_cleanup (void *o
)
6433 struct objfile
*objfile
= (struct objfile
*) o
;
6435 objfile
->psymtabs_addrmap
= NULL
;
6438 /* Compute the 'user' field for each psymtab in OBJFILE. */
6441 set_partial_user (struct objfile
*objfile
)
6445 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6447 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6448 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6454 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
6456 /* Set the 'user' field only if it is not already set. */
6457 if (pst
->dependencies
[j
]->user
== NULL
)
6458 pst
->dependencies
[j
]->user
= pst
;
6463 /* Build the partial symbol table by doing a quick pass through the
6464 .debug_info and .debug_abbrev sections. */
6467 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
6469 struct cleanup
*back_to
, *addrmap_cleanup
;
6470 struct obstack temp_obstack
;
6473 if (dwarf_read_debug
)
6475 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
6476 objfile_name (objfile
));
6479 dwarf2_per_objfile
->reading_partial_symbols
= 1;
6481 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
6483 /* Any cached compilation units will be linked by the per-objfile
6484 read_in_chain. Make sure to free them when we're done. */
6485 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
6487 build_type_psymtabs (objfile
);
6489 create_all_comp_units (objfile
);
6491 /* Create a temporary address map on a temporary obstack. We later
6492 copy this to the final obstack. */
6493 obstack_init (&temp_obstack
);
6494 make_cleanup_obstack_free (&temp_obstack
);
6495 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
6496 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
6498 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6500 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6502 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
6505 /* This has to wait until we read the CUs, we need the list of DWOs. */
6506 process_skeletonless_type_units (objfile
);
6508 /* Now that all TUs have been processed we can fill in the dependencies. */
6509 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
6511 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
6512 build_type_psymtab_dependencies
, NULL
);
6515 if (dwarf_read_debug
)
6518 set_partial_user (objfile
);
6520 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
6521 &objfile
->objfile_obstack
);
6522 discard_cleanups (addrmap_cleanup
);
6524 do_cleanups (back_to
);
6526 if (dwarf_read_debug
)
6527 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
6528 objfile_name (objfile
));
6531 /* die_reader_func for load_partial_comp_unit. */
6534 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
6535 const gdb_byte
*info_ptr
,
6536 struct die_info
*comp_unit_die
,
6540 struct dwarf2_cu
*cu
= reader
->cu
;
6542 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
6544 /* Check if comp unit has_children.
6545 If so, read the rest of the partial symbols from this comp unit.
6546 If not, there's no more debug_info for this comp unit. */
6548 load_partial_dies (reader
, info_ptr
, 0);
6551 /* Load the partial DIEs for a secondary CU into memory.
6552 This is also used when rereading a primary CU with load_all_dies. */
6555 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
6557 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
6558 load_partial_comp_unit_reader
, NULL
);
6562 read_comp_units_from_section (struct objfile
*objfile
,
6563 struct dwarf2_section_info
*section
,
6564 unsigned int is_dwz
,
6567 struct dwarf2_per_cu_data
***all_comp_units
)
6569 const gdb_byte
*info_ptr
;
6570 bfd
*abfd
= get_section_bfd_owner (section
);
6572 if (dwarf_read_debug
)
6573 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
6574 get_section_name (section
),
6575 get_section_file_name (section
));
6577 dwarf2_read_section (objfile
, section
);
6579 info_ptr
= section
->buffer
;
6581 while (info_ptr
< section
->buffer
+ section
->size
)
6583 unsigned int length
, initial_length_size
;
6584 struct dwarf2_per_cu_data
*this_cu
;
6587 offset
.sect_off
= info_ptr
- section
->buffer
;
6589 /* Read just enough information to find out where the next
6590 compilation unit is. */
6591 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6593 /* Save the compilation unit for later lookup. */
6594 this_cu
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_per_cu_data
);
6595 memset (this_cu
, 0, sizeof (*this_cu
));
6596 this_cu
->offset
= offset
;
6597 this_cu
->length
= length
+ initial_length_size
;
6598 this_cu
->is_dwz
= is_dwz
;
6599 this_cu
->objfile
= objfile
;
6600 this_cu
->section
= section
;
6602 if (*n_comp_units
== *n_allocated
)
6605 *all_comp_units
= XRESIZEVEC (struct dwarf2_per_cu_data
*,
6606 *all_comp_units
, *n_allocated
);
6608 (*all_comp_units
)[*n_comp_units
] = this_cu
;
6611 info_ptr
= info_ptr
+ this_cu
->length
;
6615 /* Create a list of all compilation units in OBJFILE.
6616 This is only done for -readnow and building partial symtabs. */
6619 create_all_comp_units (struct objfile
*objfile
)
6623 struct dwarf2_per_cu_data
**all_comp_units
;
6624 struct dwz_file
*dwz
;
6628 all_comp_units
= XNEWVEC (struct dwarf2_per_cu_data
*, n_allocated
);
6630 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
, 0,
6631 &n_allocated
, &n_comp_units
, &all_comp_units
);
6633 dwz
= dwarf2_get_dwz_file ();
6635 read_comp_units_from_section (objfile
, &dwz
->info
, 1,
6636 &n_allocated
, &n_comp_units
,
6639 dwarf2_per_objfile
->all_comp_units
= XOBNEWVEC (&objfile
->objfile_obstack
,
6640 struct dwarf2_per_cu_data
*,
6642 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
6643 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6644 xfree (all_comp_units
);
6645 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
6648 /* Process all loaded DIEs for compilation unit CU, starting at
6649 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
6650 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6651 DW_AT_ranges). See the comments of add_partial_subprogram on how
6652 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
6655 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
6656 CORE_ADDR
*highpc
, int set_addrmap
,
6657 struct dwarf2_cu
*cu
)
6659 struct partial_die_info
*pdi
;
6661 /* Now, march along the PDI's, descending into ones which have
6662 interesting children but skipping the children of the other ones,
6663 until we reach the end of the compilation unit. */
6669 fixup_partial_die (pdi
, cu
);
6671 /* Anonymous namespaces or modules have no name but have interesting
6672 children, so we need to look at them. Ditto for anonymous
6675 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
6676 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
6677 || pdi
->tag
== DW_TAG_imported_unit
)
6681 case DW_TAG_subprogram
:
6682 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6684 case DW_TAG_constant
:
6685 case DW_TAG_variable
:
6686 case DW_TAG_typedef
:
6687 case DW_TAG_union_type
:
6688 if (!pdi
->is_declaration
)
6690 add_partial_symbol (pdi
, cu
);
6693 case DW_TAG_class_type
:
6694 case DW_TAG_interface_type
:
6695 case DW_TAG_structure_type
:
6696 if (!pdi
->is_declaration
)
6698 add_partial_symbol (pdi
, cu
);
6700 if (cu
->language
== language_rust
&& pdi
->has_children
)
6701 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
6704 case DW_TAG_enumeration_type
:
6705 if (!pdi
->is_declaration
)
6706 add_partial_enumeration (pdi
, cu
);
6708 case DW_TAG_base_type
:
6709 case DW_TAG_subrange_type
:
6710 /* File scope base type definitions are added to the partial
6712 add_partial_symbol (pdi
, cu
);
6714 case DW_TAG_namespace
:
6715 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6718 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6720 case DW_TAG_imported_unit
:
6722 struct dwarf2_per_cu_data
*per_cu
;
6724 /* For now we don't handle imported units in type units. */
6725 if (cu
->per_cu
->is_debug_types
)
6727 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6728 " supported in type units [in module %s]"),
6729 objfile_name (cu
->objfile
));
6732 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
6736 /* Go read the partial unit, if needed. */
6737 if (per_cu
->v
.psymtab
== NULL
)
6738 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
6740 VEC_safe_push (dwarf2_per_cu_ptr
,
6741 cu
->per_cu
->imported_symtabs
, per_cu
);
6744 case DW_TAG_imported_declaration
:
6745 add_partial_symbol (pdi
, cu
);
6752 /* If the die has a sibling, skip to the sibling. */
6754 pdi
= pdi
->die_sibling
;
6758 /* Functions used to compute the fully scoped name of a partial DIE.
6760 Normally, this is simple. For C++, the parent DIE's fully scoped
6761 name is concatenated with "::" and the partial DIE's name.
6762 Enumerators are an exception; they use the scope of their parent
6763 enumeration type, i.e. the name of the enumeration type is not
6764 prepended to the enumerator.
6766 There are two complexities. One is DW_AT_specification; in this
6767 case "parent" means the parent of the target of the specification,
6768 instead of the direct parent of the DIE. The other is compilers
6769 which do not emit DW_TAG_namespace; in this case we try to guess
6770 the fully qualified name of structure types from their members'
6771 linkage names. This must be done using the DIE's children rather
6772 than the children of any DW_AT_specification target. We only need
6773 to do this for structures at the top level, i.e. if the target of
6774 any DW_AT_specification (if any; otherwise the DIE itself) does not
6777 /* Compute the scope prefix associated with PDI's parent, in
6778 compilation unit CU. The result will be allocated on CU's
6779 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6780 field. NULL is returned if no prefix is necessary. */
6782 partial_die_parent_scope (struct partial_die_info
*pdi
,
6783 struct dwarf2_cu
*cu
)
6785 const char *grandparent_scope
;
6786 struct partial_die_info
*parent
, *real_pdi
;
6788 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6789 then this means the parent of the specification DIE. */
6792 while (real_pdi
->has_specification
)
6793 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
6794 real_pdi
->spec_is_dwz
, cu
);
6796 parent
= real_pdi
->die_parent
;
6800 if (parent
->scope_set
)
6801 return parent
->scope
;
6803 fixup_partial_die (parent
, cu
);
6805 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
6807 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6808 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6809 Work around this problem here. */
6810 if (cu
->language
== language_cplus
6811 && parent
->tag
== DW_TAG_namespace
6812 && strcmp (parent
->name
, "::") == 0
6813 && grandparent_scope
== NULL
)
6815 parent
->scope
= NULL
;
6816 parent
->scope_set
= 1;
6820 if (pdi
->tag
== DW_TAG_enumerator
)
6821 /* Enumerators should not get the name of the enumeration as a prefix. */
6822 parent
->scope
= grandparent_scope
;
6823 else if (parent
->tag
== DW_TAG_namespace
6824 || parent
->tag
== DW_TAG_module
6825 || parent
->tag
== DW_TAG_structure_type
6826 || parent
->tag
== DW_TAG_class_type
6827 || parent
->tag
== DW_TAG_interface_type
6828 || parent
->tag
== DW_TAG_union_type
6829 || parent
->tag
== DW_TAG_enumeration_type
)
6831 if (grandparent_scope
== NULL
)
6832 parent
->scope
= parent
->name
;
6834 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
6836 parent
->name
, 0, cu
);
6840 /* FIXME drow/2004-04-01: What should we be doing with
6841 function-local names? For partial symbols, we should probably be
6843 complaint (&symfile_complaints
,
6844 _("unhandled containing DIE tag %d for DIE at %d"),
6845 parent
->tag
, pdi
->offset
.sect_off
);
6846 parent
->scope
= grandparent_scope
;
6849 parent
->scope_set
= 1;
6850 return parent
->scope
;
6853 /* Return the fully scoped name associated with PDI, from compilation unit
6854 CU. The result will be allocated with malloc. */
6857 partial_die_full_name (struct partial_die_info
*pdi
,
6858 struct dwarf2_cu
*cu
)
6860 const char *parent_scope
;
6862 /* If this is a template instantiation, we can not work out the
6863 template arguments from partial DIEs. So, unfortunately, we have
6864 to go through the full DIEs. At least any work we do building
6865 types here will be reused if full symbols are loaded later. */
6866 if (pdi
->has_template_arguments
)
6868 fixup_partial_die (pdi
, cu
);
6870 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
6872 struct die_info
*die
;
6873 struct attribute attr
;
6874 struct dwarf2_cu
*ref_cu
= cu
;
6876 /* DW_FORM_ref_addr is using section offset. */
6877 attr
.name
= (enum dwarf_attribute
) 0;
6878 attr
.form
= DW_FORM_ref_addr
;
6879 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
6880 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
6882 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
6886 parent_scope
= partial_die_parent_scope (pdi
, cu
);
6887 if (parent_scope
== NULL
)
6890 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
6894 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
6896 struct objfile
*objfile
= cu
->objfile
;
6897 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6899 const char *actual_name
= NULL
;
6901 char *built_actual_name
;
6903 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6905 built_actual_name
= partial_die_full_name (pdi
, cu
);
6906 if (built_actual_name
!= NULL
)
6907 actual_name
= built_actual_name
;
6909 if (actual_name
== NULL
)
6910 actual_name
= pdi
->name
;
6914 case DW_TAG_subprogram
:
6915 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
);
6916 if (pdi
->is_external
|| cu
->language
== language_ada
)
6918 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6919 of the global scope. But in Ada, we want to be able to access
6920 nested procedures globally. So all Ada subprograms are stored
6921 in the global scope. */
6922 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6923 built_actual_name
!= NULL
,
6924 VAR_DOMAIN
, LOC_BLOCK
,
6925 &objfile
->global_psymbols
,
6926 addr
, cu
->language
, objfile
);
6930 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6931 built_actual_name
!= NULL
,
6932 VAR_DOMAIN
, LOC_BLOCK
,
6933 &objfile
->static_psymbols
,
6934 addr
, cu
->language
, objfile
);
6937 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
6938 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
6940 case DW_TAG_constant
:
6942 struct psymbol_allocation_list
*list
;
6944 if (pdi
->is_external
)
6945 list
= &objfile
->global_psymbols
;
6947 list
= &objfile
->static_psymbols
;
6948 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6949 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
6950 list
, 0, cu
->language
, objfile
);
6953 case DW_TAG_variable
:
6955 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
6959 && !dwarf2_per_objfile
->has_section_at_zero
)
6961 /* A global or static variable may also have been stripped
6962 out by the linker if unused, in which case its address
6963 will be nullified; do not add such variables into partial
6964 symbol table then. */
6966 else if (pdi
->is_external
)
6969 Don't enter into the minimal symbol tables as there is
6970 a minimal symbol table entry from the ELF symbols already.
6971 Enter into partial symbol table if it has a location
6972 descriptor or a type.
6973 If the location descriptor is missing, new_symbol will create
6974 a LOC_UNRESOLVED symbol, the address of the variable will then
6975 be determined from the minimal symbol table whenever the variable
6977 The address for the partial symbol table entry is not
6978 used by GDB, but it comes in handy for debugging partial symbol
6981 if (pdi
->d
.locdesc
|| pdi
->has_type
)
6982 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6983 built_actual_name
!= NULL
,
6984 VAR_DOMAIN
, LOC_STATIC
,
6985 &objfile
->global_psymbols
,
6987 cu
->language
, objfile
);
6991 int has_loc
= pdi
->d
.locdesc
!= NULL
;
6993 /* Static Variable. Skip symbols whose value we cannot know (those
6994 without location descriptors or constant values). */
6995 if (!has_loc
&& !pdi
->has_const_value
)
6997 xfree (built_actual_name
);
7001 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7002 built_actual_name
!= NULL
,
7003 VAR_DOMAIN
, LOC_STATIC
,
7004 &objfile
->static_psymbols
,
7005 has_loc
? addr
+ baseaddr
: (CORE_ADDR
) 0,
7006 cu
->language
, objfile
);
7009 case DW_TAG_typedef
:
7010 case DW_TAG_base_type
:
7011 case DW_TAG_subrange_type
:
7012 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7013 built_actual_name
!= NULL
,
7014 VAR_DOMAIN
, LOC_TYPEDEF
,
7015 &objfile
->static_psymbols
,
7016 0, cu
->language
, objfile
);
7018 case DW_TAG_imported_declaration
:
7019 case DW_TAG_namespace
:
7020 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7021 built_actual_name
!= NULL
,
7022 VAR_DOMAIN
, LOC_TYPEDEF
,
7023 &objfile
->global_psymbols
,
7024 0, cu
->language
, objfile
);
7027 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7028 built_actual_name
!= NULL
,
7029 MODULE_DOMAIN
, LOC_TYPEDEF
,
7030 &objfile
->global_psymbols
,
7031 0, cu
->language
, objfile
);
7033 case DW_TAG_class_type
:
7034 case DW_TAG_interface_type
:
7035 case DW_TAG_structure_type
:
7036 case DW_TAG_union_type
:
7037 case DW_TAG_enumeration_type
:
7038 /* Skip external references. The DWARF standard says in the section
7039 about "Structure, Union, and Class Type Entries": "An incomplete
7040 structure, union or class type is represented by a structure,
7041 union or class entry that does not have a byte size attribute
7042 and that has a DW_AT_declaration attribute." */
7043 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
7045 xfree (built_actual_name
);
7049 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
7050 static vs. global. */
7051 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7052 built_actual_name
!= NULL
,
7053 STRUCT_DOMAIN
, LOC_TYPEDEF
,
7054 cu
->language
== language_cplus
7055 ? &objfile
->global_psymbols
7056 : &objfile
->static_psymbols
,
7057 0, cu
->language
, objfile
);
7060 case DW_TAG_enumerator
:
7061 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7062 built_actual_name
!= NULL
,
7063 VAR_DOMAIN
, LOC_CONST
,
7064 cu
->language
== language_cplus
7065 ? &objfile
->global_psymbols
7066 : &objfile
->static_psymbols
,
7067 0, cu
->language
, objfile
);
7073 xfree (built_actual_name
);
7076 /* Read a partial die corresponding to a namespace; also, add a symbol
7077 corresponding to that namespace to the symbol table. NAMESPACE is
7078 the name of the enclosing namespace. */
7081 add_partial_namespace (struct partial_die_info
*pdi
,
7082 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7083 int set_addrmap
, struct dwarf2_cu
*cu
)
7085 /* Add a symbol for the namespace. */
7087 add_partial_symbol (pdi
, cu
);
7089 /* Now scan partial symbols in that namespace. */
7091 if (pdi
->has_children
)
7092 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7095 /* Read a partial die corresponding to a Fortran module. */
7098 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
7099 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
7101 /* Add a symbol for the namespace. */
7103 add_partial_symbol (pdi
, cu
);
7105 /* Now scan partial symbols in that module. */
7107 if (pdi
->has_children
)
7108 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7111 /* Read a partial die corresponding to a subprogram and create a partial
7112 symbol for that subprogram. When the CU language allows it, this
7113 routine also defines a partial symbol for each nested subprogram
7114 that this subprogram contains. If SET_ADDRMAP is true, record the
7115 covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
7116 and highest PC values found in PDI.
7118 PDI may also be a lexical block, in which case we simply search
7119 recursively for subprograms defined inside that lexical block.
7120 Again, this is only performed when the CU language allows this
7121 type of definitions. */
7124 add_partial_subprogram (struct partial_die_info
*pdi
,
7125 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7126 int set_addrmap
, struct dwarf2_cu
*cu
)
7128 if (pdi
->tag
== DW_TAG_subprogram
)
7130 if (pdi
->has_pc_info
)
7132 if (pdi
->lowpc
< *lowpc
)
7133 *lowpc
= pdi
->lowpc
;
7134 if (pdi
->highpc
> *highpc
)
7135 *highpc
= pdi
->highpc
;
7138 struct objfile
*objfile
= cu
->objfile
;
7139 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7144 baseaddr
= ANOFFSET (objfile
->section_offsets
,
7145 SECT_OFF_TEXT (objfile
));
7146 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7147 pdi
->lowpc
+ baseaddr
);
7148 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7149 pdi
->highpc
+ baseaddr
);
7150 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
7151 cu
->per_cu
->v
.psymtab
);
7155 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
7157 if (!pdi
->is_declaration
)
7158 /* Ignore subprogram DIEs that do not have a name, they are
7159 illegal. Do not emit a complaint at this point, we will
7160 do so when we convert this psymtab into a symtab. */
7162 add_partial_symbol (pdi
, cu
);
7166 if (! pdi
->has_children
)
7169 if (cu
->language
== language_ada
)
7171 pdi
= pdi
->die_child
;
7174 fixup_partial_die (pdi
, cu
);
7175 if (pdi
->tag
== DW_TAG_subprogram
7176 || pdi
->tag
== DW_TAG_lexical_block
)
7177 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7178 pdi
= pdi
->die_sibling
;
7183 /* Read a partial die corresponding to an enumeration type. */
7186 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
7187 struct dwarf2_cu
*cu
)
7189 struct partial_die_info
*pdi
;
7191 if (enum_pdi
->name
!= NULL
)
7192 add_partial_symbol (enum_pdi
, cu
);
7194 pdi
= enum_pdi
->die_child
;
7197 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
7198 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
7200 add_partial_symbol (pdi
, cu
);
7201 pdi
= pdi
->die_sibling
;
7205 /* Return the initial uleb128 in the die at INFO_PTR. */
7208 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
7210 unsigned int bytes_read
;
7212 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7215 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7216 Return the corresponding abbrev, or NULL if the number is zero (indicating
7217 an empty DIE). In either case *BYTES_READ will be set to the length of
7218 the initial number. */
7220 static struct abbrev_info
*
7221 peek_die_abbrev (const gdb_byte
*info_ptr
, unsigned int *bytes_read
,
7222 struct dwarf2_cu
*cu
)
7224 bfd
*abfd
= cu
->objfile
->obfd
;
7225 unsigned int abbrev_number
;
7226 struct abbrev_info
*abbrev
;
7228 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
7230 if (abbrev_number
== 0)
7233 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
7236 error (_("Dwarf Error: Could not find abbrev number %d in %s"
7237 " at offset 0x%x [in module %s]"),
7238 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
7239 cu
->header
.offset
.sect_off
, bfd_get_filename (abfd
));
7245 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7246 Returns a pointer to the end of a series of DIEs, terminated by an empty
7247 DIE. Any children of the skipped DIEs will also be skipped. */
7249 static const gdb_byte
*
7250 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
7252 struct dwarf2_cu
*cu
= reader
->cu
;
7253 struct abbrev_info
*abbrev
;
7254 unsigned int bytes_read
;
7258 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
7260 return info_ptr
+ bytes_read
;
7262 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
7266 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7267 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7268 abbrev corresponding to that skipped uleb128 should be passed in
7269 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7272 static const gdb_byte
*
7273 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
7274 struct abbrev_info
*abbrev
)
7276 unsigned int bytes_read
;
7277 struct attribute attr
;
7278 bfd
*abfd
= reader
->abfd
;
7279 struct dwarf2_cu
*cu
= reader
->cu
;
7280 const gdb_byte
*buffer
= reader
->buffer
;
7281 const gdb_byte
*buffer_end
= reader
->buffer_end
;
7282 unsigned int form
, i
;
7284 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
7286 /* The only abbrev we care about is DW_AT_sibling. */
7287 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
7289 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
7290 if (attr
.form
== DW_FORM_ref_addr
)
7291 complaint (&symfile_complaints
,
7292 _("ignoring absolute DW_AT_sibling"));
7295 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
7296 const gdb_byte
*sibling_ptr
= buffer
+ off
;
7298 if (sibling_ptr
< info_ptr
)
7299 complaint (&symfile_complaints
,
7300 _("DW_AT_sibling points backwards"));
7301 else if (sibling_ptr
> reader
->buffer_end
)
7302 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
7308 /* If it isn't DW_AT_sibling, skip this attribute. */
7309 form
= abbrev
->attrs
[i
].form
;
7313 case DW_FORM_ref_addr
:
7314 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7315 and later it is offset sized. */
7316 if (cu
->header
.version
== 2)
7317 info_ptr
+= cu
->header
.addr_size
;
7319 info_ptr
+= cu
->header
.offset_size
;
7321 case DW_FORM_GNU_ref_alt
:
7322 info_ptr
+= cu
->header
.offset_size
;
7325 info_ptr
+= cu
->header
.addr_size
;
7332 case DW_FORM_flag_present
:
7344 case DW_FORM_ref_sig8
:
7347 case DW_FORM_string
:
7348 read_direct_string (abfd
, info_ptr
, &bytes_read
);
7349 info_ptr
+= bytes_read
;
7351 case DW_FORM_sec_offset
:
7353 case DW_FORM_GNU_strp_alt
:
7354 info_ptr
+= cu
->header
.offset_size
;
7356 case DW_FORM_exprloc
:
7358 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7359 info_ptr
+= bytes_read
;
7361 case DW_FORM_block1
:
7362 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
7364 case DW_FORM_block2
:
7365 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
7367 case DW_FORM_block4
:
7368 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
7372 case DW_FORM_ref_udata
:
7373 case DW_FORM_GNU_addr_index
:
7374 case DW_FORM_GNU_str_index
:
7375 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
7377 case DW_FORM_indirect
:
7378 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7379 info_ptr
+= bytes_read
;
7380 /* We need to continue parsing from here, so just go back to
7382 goto skip_attribute
;
7385 error (_("Dwarf Error: Cannot handle %s "
7386 "in DWARF reader [in module %s]"),
7387 dwarf_form_name (form
),
7388 bfd_get_filename (abfd
));
7392 if (abbrev
->has_children
)
7393 return skip_children (reader
, info_ptr
);
7398 /* Locate ORIG_PDI's sibling.
7399 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7401 static const gdb_byte
*
7402 locate_pdi_sibling (const struct die_reader_specs
*reader
,
7403 struct partial_die_info
*orig_pdi
,
7404 const gdb_byte
*info_ptr
)
7406 /* Do we know the sibling already? */
7408 if (orig_pdi
->sibling
)
7409 return orig_pdi
->sibling
;
7411 /* Are there any children to deal with? */
7413 if (!orig_pdi
->has_children
)
7416 /* Skip the children the long way. */
7418 return skip_children (reader
, info_ptr
);
7421 /* Expand this partial symbol table into a full symbol table. SELF is
7425 dwarf2_read_symtab (struct partial_symtab
*self
,
7426 struct objfile
*objfile
)
7430 warning (_("bug: psymtab for %s is already read in."),
7437 printf_filtered (_("Reading in symbols for %s..."),
7439 gdb_flush (gdb_stdout
);
7442 /* Restore our global data. */
7444 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
7445 dwarf2_objfile_data_key
);
7447 /* If this psymtab is constructed from a debug-only objfile, the
7448 has_section_at_zero flag will not necessarily be correct. We
7449 can get the correct value for this flag by looking at the data
7450 associated with the (presumably stripped) associated objfile. */
7451 if (objfile
->separate_debug_objfile_backlink
)
7453 struct dwarf2_per_objfile
*dpo_backlink
7454 = ((struct dwarf2_per_objfile
*)
7455 objfile_data (objfile
->separate_debug_objfile_backlink
,
7456 dwarf2_objfile_data_key
));
7458 dwarf2_per_objfile
->has_section_at_zero
7459 = dpo_backlink
->has_section_at_zero
;
7462 dwarf2_per_objfile
->reading_partial_symbols
= 0;
7464 psymtab_to_symtab_1 (self
);
7466 /* Finish up the debug error message. */
7468 printf_filtered (_("done.\n"));
7471 process_cu_includes ();
7474 /* Reading in full CUs. */
7476 /* Add PER_CU to the queue. */
7479 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
7480 enum language pretend_language
)
7482 struct dwarf2_queue_item
*item
;
7485 item
= XNEW (struct dwarf2_queue_item
);
7486 item
->per_cu
= per_cu
;
7487 item
->pretend_language
= pretend_language
;
7490 if (dwarf2_queue
== NULL
)
7491 dwarf2_queue
= item
;
7493 dwarf2_queue_tail
->next
= item
;
7495 dwarf2_queue_tail
= item
;
7498 /* If PER_CU is not yet queued, add it to the queue.
7499 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7501 The result is non-zero if PER_CU was queued, otherwise the result is zero
7502 meaning either PER_CU is already queued or it is already loaded.
7504 N.B. There is an invariant here that if a CU is queued then it is loaded.
7505 The caller is required to load PER_CU if we return non-zero. */
7508 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
7509 struct dwarf2_per_cu_data
*per_cu
,
7510 enum language pretend_language
)
7512 /* We may arrive here during partial symbol reading, if we need full
7513 DIEs to process an unusual case (e.g. template arguments). Do
7514 not queue PER_CU, just tell our caller to load its DIEs. */
7515 if (dwarf2_per_objfile
->reading_partial_symbols
)
7517 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
7522 /* Mark the dependence relation so that we don't flush PER_CU
7524 if (dependent_cu
!= NULL
)
7525 dwarf2_add_dependence (dependent_cu
, per_cu
);
7527 /* If it's already on the queue, we have nothing to do. */
7531 /* If the compilation unit is already loaded, just mark it as
7533 if (per_cu
->cu
!= NULL
)
7535 per_cu
->cu
->last_used
= 0;
7539 /* Add it to the queue. */
7540 queue_comp_unit (per_cu
, pretend_language
);
7545 /* Process the queue. */
7548 process_queue (void)
7550 struct dwarf2_queue_item
*item
, *next_item
;
7552 if (dwarf_read_debug
)
7554 fprintf_unfiltered (gdb_stdlog
,
7555 "Expanding one or more symtabs of objfile %s ...\n",
7556 objfile_name (dwarf2_per_objfile
->objfile
));
7559 /* The queue starts out with one item, but following a DIE reference
7560 may load a new CU, adding it to the end of the queue. */
7561 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
7563 if ((dwarf2_per_objfile
->using_index
7564 ? !item
->per_cu
->v
.quick
->compunit_symtab
7565 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
7566 /* Skip dummy CUs. */
7567 && item
->per_cu
->cu
!= NULL
)
7569 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
7570 unsigned int debug_print_threshold
;
7573 if (per_cu
->is_debug_types
)
7575 struct signatured_type
*sig_type
=
7576 (struct signatured_type
*) per_cu
;
7578 sprintf (buf
, "TU %s at offset 0x%x",
7579 hex_string (sig_type
->signature
),
7580 per_cu
->offset
.sect_off
);
7581 /* There can be 100s of TUs.
7582 Only print them in verbose mode. */
7583 debug_print_threshold
= 2;
7587 sprintf (buf
, "CU at offset 0x%x", per_cu
->offset
.sect_off
);
7588 debug_print_threshold
= 1;
7591 if (dwarf_read_debug
>= debug_print_threshold
)
7592 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
7594 if (per_cu
->is_debug_types
)
7595 process_full_type_unit (per_cu
, item
->pretend_language
);
7597 process_full_comp_unit (per_cu
, item
->pretend_language
);
7599 if (dwarf_read_debug
>= debug_print_threshold
)
7600 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
7603 item
->per_cu
->queued
= 0;
7604 next_item
= item
->next
;
7608 dwarf2_queue_tail
= NULL
;
7610 if (dwarf_read_debug
)
7612 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
7613 objfile_name (dwarf2_per_objfile
->objfile
));
7617 /* Free all allocated queue entries. This function only releases anything if
7618 an error was thrown; if the queue was processed then it would have been
7619 freed as we went along. */
7622 dwarf2_release_queue (void *dummy
)
7624 struct dwarf2_queue_item
*item
, *last
;
7626 item
= dwarf2_queue
;
7629 /* Anything still marked queued is likely to be in an
7630 inconsistent state, so discard it. */
7631 if (item
->per_cu
->queued
)
7633 if (item
->per_cu
->cu
!= NULL
)
7634 free_one_cached_comp_unit (item
->per_cu
);
7635 item
->per_cu
->queued
= 0;
7643 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
7646 /* Read in full symbols for PST, and anything it depends on. */
7649 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
7651 struct dwarf2_per_cu_data
*per_cu
;
7657 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
7658 if (!pst
->dependencies
[i
]->readin
7659 && pst
->dependencies
[i
]->user
== NULL
)
7661 /* Inform about additional files that need to be read in. */
7664 /* FIXME: i18n: Need to make this a single string. */
7665 fputs_filtered (" ", gdb_stdout
);
7667 fputs_filtered ("and ", gdb_stdout
);
7669 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
7670 wrap_here (""); /* Flush output. */
7671 gdb_flush (gdb_stdout
);
7673 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
7676 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
7680 /* It's an include file, no symbols to read for it.
7681 Everything is in the parent symtab. */
7686 dw2_do_instantiate_symtab (per_cu
);
7689 /* Trivial hash function for die_info: the hash value of a DIE
7690 is its offset in .debug_info for this objfile. */
7693 die_hash (const void *item
)
7695 const struct die_info
*die
= (const struct die_info
*) item
;
7697 return die
->offset
.sect_off
;
7700 /* Trivial comparison function for die_info structures: two DIEs
7701 are equal if they have the same offset. */
7704 die_eq (const void *item_lhs
, const void *item_rhs
)
7706 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
7707 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
7709 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
7712 /* die_reader_func for load_full_comp_unit.
7713 This is identical to read_signatured_type_reader,
7714 but is kept separate for now. */
7717 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
7718 const gdb_byte
*info_ptr
,
7719 struct die_info
*comp_unit_die
,
7723 struct dwarf2_cu
*cu
= reader
->cu
;
7724 enum language
*language_ptr
= (enum language
*) data
;
7726 gdb_assert (cu
->die_hash
== NULL
);
7728 htab_create_alloc_ex (cu
->header
.length
/ 12,
7732 &cu
->comp_unit_obstack
,
7733 hashtab_obstack_allocate
,
7734 dummy_obstack_deallocate
);
7737 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
7738 &info_ptr
, comp_unit_die
);
7739 cu
->dies
= comp_unit_die
;
7740 /* comp_unit_die is not stored in die_hash, no need. */
7742 /* We try not to read any attributes in this function, because not
7743 all CUs needed for references have been loaded yet, and symbol
7744 table processing isn't initialized. But we have to set the CU language,
7745 or we won't be able to build types correctly.
7746 Similarly, if we do not read the producer, we can not apply
7747 producer-specific interpretation. */
7748 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
7751 /* Load the DIEs associated with PER_CU into memory. */
7754 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7755 enum language pretend_language
)
7757 gdb_assert (! this_cu
->is_debug_types
);
7759 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
7760 load_full_comp_unit_reader
, &pretend_language
);
7763 /* Add a DIE to the delayed physname list. */
7766 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
7767 const char *name
, struct die_info
*die
,
7768 struct dwarf2_cu
*cu
)
7770 struct delayed_method_info mi
;
7772 mi
.fnfield_index
= fnfield_index
;
7776 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
7779 /* A cleanup for freeing the delayed method list. */
7782 free_delayed_list (void *ptr
)
7784 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
7785 if (cu
->method_list
!= NULL
)
7787 VEC_free (delayed_method_info
, cu
->method_list
);
7788 cu
->method_list
= NULL
;
7792 /* Compute the physnames of any methods on the CU's method list.
7794 The computation of method physnames is delayed in order to avoid the
7795 (bad) condition that one of the method's formal parameters is of an as yet
7799 compute_delayed_physnames (struct dwarf2_cu
*cu
)
7802 struct delayed_method_info
*mi
;
7803 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
7805 const char *physname
;
7806 struct fn_fieldlist
*fn_flp
7807 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
7808 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
7809 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
->index
)
7810 = physname
? physname
: "";
7814 /* Go objects should be embedded in a DW_TAG_module DIE,
7815 and it's not clear if/how imported objects will appear.
7816 To keep Go support simple until that's worked out,
7817 go back through what we've read and create something usable.
7818 We could do this while processing each DIE, and feels kinda cleaner,
7819 but that way is more invasive.
7820 This is to, for example, allow the user to type "p var" or "b main"
7821 without having to specify the package name, and allow lookups
7822 of module.object to work in contexts that use the expression
7826 fixup_go_packaging (struct dwarf2_cu
*cu
)
7828 char *package_name
= NULL
;
7829 struct pending
*list
;
7832 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
7834 for (i
= 0; i
< list
->nsyms
; ++i
)
7836 struct symbol
*sym
= list
->symbol
[i
];
7838 if (SYMBOL_LANGUAGE (sym
) == language_go
7839 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
7841 char *this_package_name
= go_symbol_package_name (sym
);
7843 if (this_package_name
== NULL
)
7845 if (package_name
== NULL
)
7846 package_name
= this_package_name
;
7849 if (strcmp (package_name
, this_package_name
) != 0)
7850 complaint (&symfile_complaints
,
7851 _("Symtab %s has objects from two different Go packages: %s and %s"),
7852 (symbol_symtab (sym
) != NULL
7853 ? symtab_to_filename_for_display
7854 (symbol_symtab (sym
))
7855 : objfile_name (cu
->objfile
)),
7856 this_package_name
, package_name
);
7857 xfree (this_package_name
);
7863 if (package_name
!= NULL
)
7865 struct objfile
*objfile
= cu
->objfile
;
7866 const char *saved_package_name
7867 = (const char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
7869 strlen (package_name
));
7870 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
7871 saved_package_name
);
7874 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7876 sym
= allocate_symbol (objfile
);
7877 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
7878 SYMBOL_SET_NAMES (sym
, saved_package_name
,
7879 strlen (saved_package_name
), 0, objfile
);
7880 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7881 e.g., "main" finds the "main" module and not C's main(). */
7882 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7883 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
7884 SYMBOL_TYPE (sym
) = type
;
7886 add_symbol_to_list (sym
, &global_symbols
);
7888 xfree (package_name
);
7892 /* Return the symtab for PER_CU. This works properly regardless of
7893 whether we're using the index or psymtabs. */
7895 static struct compunit_symtab
*
7896 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
7898 return (dwarf2_per_objfile
->using_index
7899 ? per_cu
->v
.quick
->compunit_symtab
7900 : per_cu
->v
.psymtab
->compunit_symtab
);
7903 /* A helper function for computing the list of all symbol tables
7904 included by PER_CU. */
7907 recursively_compute_inclusions (VEC (compunit_symtab_ptr
) **result
,
7908 htab_t all_children
, htab_t all_type_symtabs
,
7909 struct dwarf2_per_cu_data
*per_cu
,
7910 struct compunit_symtab
*immediate_parent
)
7914 struct compunit_symtab
*cust
;
7915 struct dwarf2_per_cu_data
*iter
;
7917 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
7920 /* This inclusion and its children have been processed. */
7925 /* Only add a CU if it has a symbol table. */
7926 cust
= get_compunit_symtab (per_cu
);
7929 /* If this is a type unit only add its symbol table if we haven't
7930 seen it yet (type unit per_cu's can share symtabs). */
7931 if (per_cu
->is_debug_types
)
7933 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
7937 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7938 if (cust
->user
== NULL
)
7939 cust
->user
= immediate_parent
;
7944 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7945 if (cust
->user
== NULL
)
7946 cust
->user
= immediate_parent
;
7951 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
7954 recursively_compute_inclusions (result
, all_children
,
7955 all_type_symtabs
, iter
, cust
);
7959 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
7963 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
7965 gdb_assert (! per_cu
->is_debug_types
);
7967 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
7970 struct dwarf2_per_cu_data
*per_cu_iter
;
7971 struct compunit_symtab
*compunit_symtab_iter
;
7972 VEC (compunit_symtab_ptr
) *result_symtabs
= NULL
;
7973 htab_t all_children
, all_type_symtabs
;
7974 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
7976 /* If we don't have a symtab, we can just skip this case. */
7980 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7981 NULL
, xcalloc
, xfree
);
7982 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7983 NULL
, xcalloc
, xfree
);
7986 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
7990 recursively_compute_inclusions (&result_symtabs
, all_children
,
7991 all_type_symtabs
, per_cu_iter
,
7995 /* Now we have a transitive closure of all the included symtabs. */
7996 len
= VEC_length (compunit_symtab_ptr
, result_symtabs
);
7998 = XOBNEWVEC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
7999 struct compunit_symtab
*, len
+ 1);
8001 VEC_iterate (compunit_symtab_ptr
, result_symtabs
, ix
,
8002 compunit_symtab_iter
);
8004 cust
->includes
[ix
] = compunit_symtab_iter
;
8005 cust
->includes
[len
] = NULL
;
8007 VEC_free (compunit_symtab_ptr
, result_symtabs
);
8008 htab_delete (all_children
);
8009 htab_delete (all_type_symtabs
);
8013 /* Compute the 'includes' field for the symtabs of all the CUs we just
8017 process_cu_includes (void)
8020 struct dwarf2_per_cu_data
*iter
;
8023 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
8027 if (! iter
->is_debug_types
)
8028 compute_compunit_symtab_includes (iter
);
8031 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
8034 /* Generate full symbol information for PER_CU, whose DIEs have
8035 already been loaded into memory. */
8038 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
8039 enum language pretend_language
)
8041 struct dwarf2_cu
*cu
= per_cu
->cu
;
8042 struct objfile
*objfile
= per_cu
->objfile
;
8043 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8044 CORE_ADDR lowpc
, highpc
;
8045 struct compunit_symtab
*cust
;
8046 struct cleanup
*back_to
, *delayed_list_cleanup
;
8048 struct block
*static_block
;
8051 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8054 back_to
= make_cleanup (really_free_pendings
, NULL
);
8055 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8057 cu
->list_in_scope
= &file_symbols
;
8059 cu
->language
= pretend_language
;
8060 cu
->language_defn
= language_def (cu
->language
);
8062 /* Do line number decoding in read_file_scope () */
8063 process_die (cu
->dies
, cu
);
8065 /* For now fudge the Go package. */
8066 if (cu
->language
== language_go
)
8067 fixup_go_packaging (cu
);
8069 /* Now that we have processed all the DIEs in the CU, all the types
8070 should be complete, and it should now be safe to compute all of the
8072 compute_delayed_physnames (cu
);
8073 do_cleanups (delayed_list_cleanup
);
8075 /* Some compilers don't define a DW_AT_high_pc attribute for the
8076 compilation unit. If the DW_AT_high_pc is missing, synthesize
8077 it, by scanning the DIE's below the compilation unit. */
8078 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
8080 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
8081 static_block
= end_symtab_get_static_block (addr
, 0, 1);
8083 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
8084 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
8085 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
8086 addrmap to help ensure it has an accurate map of pc values belonging to
8088 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
8090 cust
= end_symtab_from_static_block (static_block
,
8091 SECT_OFF_TEXT (objfile
), 0);
8095 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
8097 /* Set symtab language to language from DW_AT_language. If the
8098 compilation is from a C file generated by language preprocessors, do
8099 not set the language if it was already deduced by start_subfile. */
8100 if (!(cu
->language
== language_c
8101 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
8102 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8104 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
8105 produce DW_AT_location with location lists but it can be possibly
8106 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
8107 there were bugs in prologue debug info, fixed later in GCC-4.5
8108 by "unwind info for epilogues" patch (which is not directly related).
8110 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
8111 needed, it would be wrong due to missing DW_AT_producer there.
8113 Still one can confuse GDB by using non-standard GCC compilation
8114 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
8116 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
8117 cust
->locations_valid
= 1;
8119 if (gcc_4_minor
>= 5)
8120 cust
->epilogue_unwind_valid
= 1;
8122 cust
->call_site_htab
= cu
->call_site_htab
;
8125 if (dwarf2_per_objfile
->using_index
)
8126 per_cu
->v
.quick
->compunit_symtab
= cust
;
8129 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8130 pst
->compunit_symtab
= cust
;
8134 /* Push it for inclusion processing later. */
8135 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
8137 do_cleanups (back_to
);
8140 /* Generate full symbol information for type unit PER_CU, whose DIEs have
8141 already been loaded into memory. */
8144 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
8145 enum language pretend_language
)
8147 struct dwarf2_cu
*cu
= per_cu
->cu
;
8148 struct objfile
*objfile
= per_cu
->objfile
;
8149 struct compunit_symtab
*cust
;
8150 struct cleanup
*back_to
, *delayed_list_cleanup
;
8151 struct signatured_type
*sig_type
;
8153 gdb_assert (per_cu
->is_debug_types
);
8154 sig_type
= (struct signatured_type
*) per_cu
;
8157 back_to
= make_cleanup (really_free_pendings
, NULL
);
8158 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8160 cu
->list_in_scope
= &file_symbols
;
8162 cu
->language
= pretend_language
;
8163 cu
->language_defn
= language_def (cu
->language
);
8165 /* The symbol tables are set up in read_type_unit_scope. */
8166 process_die (cu
->dies
, cu
);
8168 /* For now fudge the Go package. */
8169 if (cu
->language
== language_go
)
8170 fixup_go_packaging (cu
);
8172 /* Now that we have processed all the DIEs in the CU, all the types
8173 should be complete, and it should now be safe to compute all of the
8175 compute_delayed_physnames (cu
);
8176 do_cleanups (delayed_list_cleanup
);
8178 /* TUs share symbol tables.
8179 If this is the first TU to use this symtab, complete the construction
8180 of it with end_expandable_symtab. Otherwise, complete the addition of
8181 this TU's symbols to the existing symtab. */
8182 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
8184 cust
= end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
8185 sig_type
->type_unit_group
->compunit_symtab
= cust
;
8189 /* Set symtab language to language from DW_AT_language. If the
8190 compilation is from a C file generated by language preprocessors,
8191 do not set the language if it was already deduced by
8193 if (!(cu
->language
== language_c
8194 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
8195 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8200 augment_type_symtab ();
8201 cust
= sig_type
->type_unit_group
->compunit_symtab
;
8204 if (dwarf2_per_objfile
->using_index
)
8205 per_cu
->v
.quick
->compunit_symtab
= cust
;
8208 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8209 pst
->compunit_symtab
= cust
;
8213 do_cleanups (back_to
);
8216 /* Process an imported unit DIE. */
8219 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8221 struct attribute
*attr
;
8223 /* For now we don't handle imported units in type units. */
8224 if (cu
->per_cu
->is_debug_types
)
8226 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8227 " supported in type units [in module %s]"),
8228 objfile_name (cu
->objfile
));
8231 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8234 struct dwarf2_per_cu_data
*per_cu
;
8238 offset
= dwarf2_get_ref_die_offset (attr
);
8239 is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
8240 per_cu
= dwarf2_find_containing_comp_unit (offset
, is_dwz
, cu
->objfile
);
8242 /* If necessary, add it to the queue and load its DIEs. */
8243 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
8244 load_full_comp_unit (per_cu
, cu
->language
);
8246 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8251 /* Reset the in_process bit of a die. */
8254 reset_die_in_process (void *arg
)
8256 struct die_info
*die
= (struct die_info
*) arg
;
8258 die
->in_process
= 0;
8261 /* Process a die and its children. */
8264 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8266 struct cleanup
*in_process
;
8268 /* We should only be processing those not already in process. */
8269 gdb_assert (!die
->in_process
);
8271 die
->in_process
= 1;
8272 in_process
= make_cleanup (reset_die_in_process
,die
);
8276 case DW_TAG_padding
:
8278 case DW_TAG_compile_unit
:
8279 case DW_TAG_partial_unit
:
8280 read_file_scope (die
, cu
);
8282 case DW_TAG_type_unit
:
8283 read_type_unit_scope (die
, cu
);
8285 case DW_TAG_subprogram
:
8286 case DW_TAG_inlined_subroutine
:
8287 read_func_scope (die
, cu
);
8289 case DW_TAG_lexical_block
:
8290 case DW_TAG_try_block
:
8291 case DW_TAG_catch_block
:
8292 read_lexical_block_scope (die
, cu
);
8294 case DW_TAG_GNU_call_site
:
8295 read_call_site_scope (die
, cu
);
8297 case DW_TAG_class_type
:
8298 case DW_TAG_interface_type
:
8299 case DW_TAG_structure_type
:
8300 case DW_TAG_union_type
:
8301 process_structure_scope (die
, cu
);
8303 case DW_TAG_enumeration_type
:
8304 process_enumeration_scope (die
, cu
);
8307 /* These dies have a type, but processing them does not create
8308 a symbol or recurse to process the children. Therefore we can
8309 read them on-demand through read_type_die. */
8310 case DW_TAG_subroutine_type
:
8311 case DW_TAG_set_type
:
8312 case DW_TAG_array_type
:
8313 case DW_TAG_pointer_type
:
8314 case DW_TAG_ptr_to_member_type
:
8315 case DW_TAG_reference_type
:
8316 case DW_TAG_string_type
:
8319 case DW_TAG_base_type
:
8320 case DW_TAG_subrange_type
:
8321 case DW_TAG_typedef
:
8322 /* Add a typedef symbol for the type definition, if it has a
8324 new_symbol (die
, read_type_die (die
, cu
), cu
);
8326 case DW_TAG_common_block
:
8327 read_common_block (die
, cu
);
8329 case DW_TAG_common_inclusion
:
8331 case DW_TAG_namespace
:
8332 cu
->processing_has_namespace_info
= 1;
8333 read_namespace (die
, cu
);
8336 cu
->processing_has_namespace_info
= 1;
8337 read_module (die
, cu
);
8339 case DW_TAG_imported_declaration
:
8340 cu
->processing_has_namespace_info
= 1;
8341 if (read_namespace_alias (die
, cu
))
8343 /* The declaration is not a global namespace alias: fall through. */
8344 case DW_TAG_imported_module
:
8345 cu
->processing_has_namespace_info
= 1;
8346 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
8347 || cu
->language
!= language_fortran
))
8348 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
8349 dwarf_tag_name (die
->tag
));
8350 read_import_statement (die
, cu
);
8353 case DW_TAG_imported_unit
:
8354 process_imported_unit_die (die
, cu
);
8358 new_symbol (die
, NULL
, cu
);
8362 do_cleanups (in_process
);
8365 /* DWARF name computation. */
8367 /* A helper function for dwarf2_compute_name which determines whether DIE
8368 needs to have the name of the scope prepended to the name listed in the
8372 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8374 struct attribute
*attr
;
8378 case DW_TAG_namespace
:
8379 case DW_TAG_typedef
:
8380 case DW_TAG_class_type
:
8381 case DW_TAG_interface_type
:
8382 case DW_TAG_structure_type
:
8383 case DW_TAG_union_type
:
8384 case DW_TAG_enumeration_type
:
8385 case DW_TAG_enumerator
:
8386 case DW_TAG_subprogram
:
8387 case DW_TAG_inlined_subroutine
:
8389 case DW_TAG_imported_declaration
:
8392 case DW_TAG_variable
:
8393 case DW_TAG_constant
:
8394 /* We only need to prefix "globally" visible variables. These include
8395 any variable marked with DW_AT_external or any variable that
8396 lives in a namespace. [Variables in anonymous namespaces
8397 require prefixing, but they are not DW_AT_external.] */
8399 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
8401 struct dwarf2_cu
*spec_cu
= cu
;
8403 return die_needs_namespace (die_specification (die
, &spec_cu
),
8407 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
8408 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
8409 && die
->parent
->tag
!= DW_TAG_module
)
8411 /* A variable in a lexical block of some kind does not need a
8412 namespace, even though in C++ such variables may be external
8413 and have a mangled name. */
8414 if (die
->parent
->tag
== DW_TAG_lexical_block
8415 || die
->parent
->tag
== DW_TAG_try_block
8416 || die
->parent
->tag
== DW_TAG_catch_block
8417 || die
->parent
->tag
== DW_TAG_subprogram
)
8426 /* Retrieve the last character from a mem_file. */
8429 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
8431 char *last_char_p
= (char *) object
;
8434 *last_char_p
= buffer
[length
- 1];
8437 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8438 compute the physname for the object, which include a method's:
8439 - formal parameters (C++),
8440 - receiver type (Go),
8442 The term "physname" is a bit confusing.
8443 For C++, for example, it is the demangled name.
8444 For Go, for example, it's the mangled name.
8446 For Ada, return the DIE's linkage name rather than the fully qualified
8447 name. PHYSNAME is ignored..
8449 The result is allocated on the objfile_obstack and canonicalized. */
8452 dwarf2_compute_name (const char *name
,
8453 struct die_info
*die
, struct dwarf2_cu
*cu
,
8456 struct objfile
*objfile
= cu
->objfile
;
8459 name
= dwarf2_name (die
, cu
);
8461 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
8462 but otherwise compute it by typename_concat inside GDB.
8463 FIXME: Actually this is not really true, or at least not always true.
8464 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
8465 Fortran names because there is no mangling standard. So new_symbol_full
8466 will set the demangled name to the result of dwarf2_full_name, and it is
8467 the demangled name that GDB uses if it exists. */
8468 if (cu
->language
== language_ada
8469 || (cu
->language
== language_fortran
&& physname
))
8471 /* For Ada unit, we prefer the linkage name over the name, as
8472 the former contains the exported name, which the user expects
8473 to be able to reference. Ideally, we want the user to be able
8474 to reference this entity using either natural or linkage name,
8475 but we haven't started looking at this enhancement yet. */
8476 const char *linkage_name
;
8478 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
8479 if (linkage_name
== NULL
)
8480 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8481 if (linkage_name
!= NULL
)
8482 return linkage_name
;
8485 /* These are the only languages we know how to qualify names in. */
8487 && (cu
->language
== language_cplus
8488 || cu
->language
== language_fortran
|| cu
->language
== language_d
8489 || cu
->language
== language_rust
))
8491 if (die_needs_namespace (die
, cu
))
8495 struct ui_file
*buf
;
8496 const char *canonical_name
= NULL
;
8498 prefix
= determine_prefix (die
, cu
);
8499 buf
= mem_fileopen ();
8500 if (*prefix
!= '\0')
8502 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
8505 fputs_unfiltered (prefixed_name
, buf
);
8506 xfree (prefixed_name
);
8509 fputs_unfiltered (name
, buf
);
8511 /* Template parameters may be specified in the DIE's DW_AT_name, or
8512 as children with DW_TAG_template_type_param or
8513 DW_TAG_value_type_param. If the latter, add them to the name
8514 here. If the name already has template parameters, then
8515 skip this step; some versions of GCC emit both, and
8516 it is more efficient to use the pre-computed name.
8518 Something to keep in mind about this process: it is very
8519 unlikely, or in some cases downright impossible, to produce
8520 something that will match the mangled name of a function.
8521 If the definition of the function has the same debug info,
8522 we should be able to match up with it anyway. But fallbacks
8523 using the minimal symbol, for instance to find a method
8524 implemented in a stripped copy of libstdc++, will not work.
8525 If we do not have debug info for the definition, we will have to
8526 match them up some other way.
8528 When we do name matching there is a related problem with function
8529 templates; two instantiated function templates are allowed to
8530 differ only by their return types, which we do not add here. */
8532 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
8534 struct attribute
*attr
;
8535 struct die_info
*child
;
8538 die
->building_fullname
= 1;
8540 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
8544 const gdb_byte
*bytes
;
8545 struct dwarf2_locexpr_baton
*baton
;
8548 if (child
->tag
!= DW_TAG_template_type_param
8549 && child
->tag
!= DW_TAG_template_value_param
)
8554 fputs_unfiltered ("<", buf
);
8558 fputs_unfiltered (", ", buf
);
8560 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
8563 complaint (&symfile_complaints
,
8564 _("template parameter missing DW_AT_type"));
8565 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
8568 type
= die_type (child
, cu
);
8570 if (child
->tag
== DW_TAG_template_type_param
)
8572 c_print_type (type
, "", buf
, -1, 0, &type_print_raw_options
);
8576 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
8579 complaint (&symfile_complaints
,
8580 _("template parameter missing "
8581 "DW_AT_const_value"));
8582 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
8586 dwarf2_const_value_attr (attr
, type
, name
,
8587 &cu
->comp_unit_obstack
, cu
,
8588 &value
, &bytes
, &baton
);
8590 if (TYPE_NOSIGN (type
))
8591 /* GDB prints characters as NUMBER 'CHAR'. If that's
8592 changed, this can use value_print instead. */
8593 c_printchar (value
, type
, buf
);
8596 struct value_print_options opts
;
8599 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
8603 else if (bytes
!= NULL
)
8605 v
= allocate_value (type
);
8606 memcpy (value_contents_writeable (v
), bytes
,
8607 TYPE_LENGTH (type
));
8610 v
= value_from_longest (type
, value
);
8612 /* Specify decimal so that we do not depend on
8614 get_formatted_print_options (&opts
, 'd');
8616 value_print (v
, buf
, &opts
);
8622 die
->building_fullname
= 0;
8626 /* Close the argument list, with a space if necessary
8627 (nested templates). */
8628 char last_char
= '\0';
8629 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
8630 if (last_char
== '>')
8631 fputs_unfiltered (" >", buf
);
8633 fputs_unfiltered (">", buf
);
8637 /* For C++ methods, append formal parameter type
8638 information, if PHYSNAME. */
8640 if (physname
&& die
->tag
== DW_TAG_subprogram
8641 && cu
->language
== language_cplus
)
8643 struct type
*type
= read_type_die (die
, cu
);
8645 c_type_print_args (type
, buf
, 1, cu
->language
,
8646 &type_print_raw_options
);
8648 if (cu
->language
== language_cplus
)
8650 /* Assume that an artificial first parameter is
8651 "this", but do not crash if it is not. RealView
8652 marks unnamed (and thus unused) parameters as
8653 artificial; there is no way to differentiate
8655 if (TYPE_NFIELDS (type
) > 0
8656 && TYPE_FIELD_ARTIFICIAL (type
, 0)
8657 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
8658 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
8660 fputs_unfiltered (" const", buf
);
8664 std::string intermediate_name
= ui_file_as_string (buf
);
8665 ui_file_delete (buf
);
8667 if (cu
->language
== language_cplus
)
8669 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
8670 &objfile
->per_bfd
->storage_obstack
);
8672 /* If we only computed INTERMEDIATE_NAME, or if
8673 INTERMEDIATE_NAME is already canonical, then we need to
8674 copy it to the appropriate obstack. */
8675 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
8676 name
= ((const char *)
8677 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8678 intermediate_name
.c_str (),
8679 intermediate_name
.length ()));
8681 name
= canonical_name
;
8688 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8689 If scope qualifiers are appropriate they will be added. The result
8690 will be allocated on the storage_obstack, or NULL if the DIE does
8691 not have a name. NAME may either be from a previous call to
8692 dwarf2_name or NULL.
8694 The output string will be canonicalized (if C++). */
8697 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8699 return dwarf2_compute_name (name
, die
, cu
, 0);
8702 /* Construct a physname for the given DIE in CU. NAME may either be
8703 from a previous call to dwarf2_name or NULL. The result will be
8704 allocated on the objfile_objstack or NULL if the DIE does not have a
8707 The output string will be canonicalized (if C++). */
8710 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8712 struct objfile
*objfile
= cu
->objfile
;
8713 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
8714 struct cleanup
*back_to
;
8717 /* In this case dwarf2_compute_name is just a shortcut not building anything
8719 if (!die_needs_namespace (die
, cu
))
8720 return dwarf2_compute_name (name
, die
, cu
, 1);
8722 back_to
= make_cleanup (null_cleanup
, NULL
);
8724 mangled
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
8725 if (mangled
== NULL
)
8726 mangled
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8728 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
8729 See https://github.com/rust-lang/rust/issues/32925. */
8730 if (cu
->language
== language_rust
&& mangled
!= NULL
8731 && strchr (mangled
, '{') != NULL
)
8734 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8736 if (mangled
!= NULL
)
8740 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8741 type. It is easier for GDB users to search for such functions as
8742 `name(params)' than `long name(params)'. In such case the minimal
8743 symbol names do not match the full symbol names but for template
8744 functions there is never a need to look up their definition from their
8745 declaration so the only disadvantage remains the minimal symbol
8746 variant `long name(params)' does not have the proper inferior type.
8749 if (cu
->language
== language_go
)
8751 /* This is a lie, but we already lie to the caller new_symbol_full.
8752 new_symbol_full assumes we return the mangled name.
8753 This just undoes that lie until things are cleaned up. */
8758 demangled
= gdb_demangle (mangled
,
8759 (DMGL_PARAMS
| DMGL_ANSI
| DMGL_RET_DROP
));
8763 make_cleanup (xfree
, demangled
);
8773 if (canon
== NULL
|| check_physname
)
8775 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
8777 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
8779 /* It may not mean a bug in GDB. The compiler could also
8780 compute DW_AT_linkage_name incorrectly. But in such case
8781 GDB would need to be bug-to-bug compatible. */
8783 complaint (&symfile_complaints
,
8784 _("Computed physname <%s> does not match demangled <%s> "
8785 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8786 physname
, canon
, mangled
, die
->offset
.sect_off
,
8787 objfile_name (objfile
));
8789 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8790 is available here - over computed PHYSNAME. It is safer
8791 against both buggy GDB and buggy compilers. */
8805 retval
= ((const char *)
8806 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8807 retval
, strlen (retval
)));
8809 do_cleanups (back_to
);
8813 /* Inspect DIE in CU for a namespace alias. If one exists, record
8814 a new symbol for it.
8816 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8819 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
8821 struct attribute
*attr
;
8823 /* If the die does not have a name, this is not a namespace
8825 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8829 struct die_info
*d
= die
;
8830 struct dwarf2_cu
*imported_cu
= cu
;
8832 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8833 keep inspecting DIEs until we hit the underlying import. */
8834 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8835 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
8837 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
8841 d
= follow_die_ref (d
, attr
, &imported_cu
);
8842 if (d
->tag
!= DW_TAG_imported_declaration
)
8846 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
8848 complaint (&symfile_complaints
,
8849 _("DIE at 0x%x has too many recursively imported "
8850 "declarations"), d
->offset
.sect_off
);
8857 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
8859 type
= get_die_type_at_offset (offset
, cu
->per_cu
);
8860 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
8862 /* This declaration is a global namespace alias. Add
8863 a symbol for it whose type is the aliased namespace. */
8864 new_symbol (die
, type
, cu
);
8873 /* Return the using directives repository (global or local?) to use in the
8874 current context for LANGUAGE.
8876 For Ada, imported declarations can materialize renamings, which *may* be
8877 global. However it is impossible (for now?) in DWARF to distinguish
8878 "external" imported declarations and "static" ones. As all imported
8879 declarations seem to be static in all other languages, make them all CU-wide
8880 global only in Ada. */
8882 static struct using_direct
**
8883 using_directives (enum language language
)
8885 if (language
== language_ada
&& context_stack_depth
== 0)
8886 return &global_using_directives
;
8888 return &local_using_directives
;
8891 /* Read the import statement specified by the given die and record it. */
8894 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
8896 struct objfile
*objfile
= cu
->objfile
;
8897 struct attribute
*import_attr
;
8898 struct die_info
*imported_die
, *child_die
;
8899 struct dwarf2_cu
*imported_cu
;
8900 const char *imported_name
;
8901 const char *imported_name_prefix
;
8902 const char *canonical_name
;
8903 const char *import_alias
;
8904 const char *imported_declaration
= NULL
;
8905 const char *import_prefix
;
8906 VEC (const_char_ptr
) *excludes
= NULL
;
8907 struct cleanup
*cleanups
;
8909 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8910 if (import_attr
== NULL
)
8912 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8913 dwarf_tag_name (die
->tag
));
8918 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
8919 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8920 if (imported_name
== NULL
)
8922 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8924 The import in the following code:
8938 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8939 <52> DW_AT_decl_file : 1
8940 <53> DW_AT_decl_line : 6
8941 <54> DW_AT_import : <0x75>
8942 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8944 <5b> DW_AT_decl_file : 1
8945 <5c> DW_AT_decl_line : 2
8946 <5d> DW_AT_type : <0x6e>
8948 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8949 <76> DW_AT_byte_size : 4
8950 <77> DW_AT_encoding : 5 (signed)
8952 imports the wrong die ( 0x75 instead of 0x58 ).
8953 This case will be ignored until the gcc bug is fixed. */
8957 /* Figure out the local name after import. */
8958 import_alias
= dwarf2_name (die
, cu
);
8960 /* Figure out where the statement is being imported to. */
8961 import_prefix
= determine_prefix (die
, cu
);
8963 /* Figure out what the scope of the imported die is and prepend it
8964 to the name of the imported die. */
8965 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
8967 if (imported_die
->tag
!= DW_TAG_namespace
8968 && imported_die
->tag
!= DW_TAG_module
)
8970 imported_declaration
= imported_name
;
8971 canonical_name
= imported_name_prefix
;
8973 else if (strlen (imported_name_prefix
) > 0)
8974 canonical_name
= obconcat (&objfile
->objfile_obstack
,
8975 imported_name_prefix
,
8976 (cu
->language
== language_d
? "." : "::"),
8977 imported_name
, (char *) NULL
);
8979 canonical_name
= imported_name
;
8981 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
8983 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
8984 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
8985 child_die
= sibling_die (child_die
))
8987 /* DWARF-4: A Fortran use statement with a “rename list” may be
8988 represented by an imported module entry with an import attribute
8989 referring to the module and owned entries corresponding to those
8990 entities that are renamed as part of being imported. */
8992 if (child_die
->tag
!= DW_TAG_imported_declaration
)
8994 complaint (&symfile_complaints
,
8995 _("child DW_TAG_imported_declaration expected "
8996 "- DIE at 0x%x [in module %s]"),
8997 child_die
->offset
.sect_off
, objfile_name (objfile
));
9001 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
9002 if (import_attr
== NULL
)
9004 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
9005 dwarf_tag_name (child_die
->tag
));
9010 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
9012 imported_name
= dwarf2_name (imported_die
, imported_cu
);
9013 if (imported_name
== NULL
)
9015 complaint (&symfile_complaints
,
9016 _("child DW_TAG_imported_declaration has unknown "
9017 "imported name - DIE at 0x%x [in module %s]"),
9018 child_die
->offset
.sect_off
, objfile_name (objfile
));
9022 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
9024 process_die (child_die
, cu
);
9027 add_using_directive (using_directives (cu
->language
),
9031 imported_declaration
,
9034 &objfile
->objfile_obstack
);
9036 do_cleanups (cleanups
);
9039 /* Cleanup function for handle_DW_AT_stmt_list. */
9042 free_cu_line_header (void *arg
)
9044 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) arg
;
9046 free_line_header (cu
->line_header
);
9047 cu
->line_header
= NULL
;
9050 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
9051 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
9052 this, it was first present in GCC release 4.3.0. */
9055 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
9057 if (!cu
->checked_producer
)
9058 check_producer (cu
);
9060 return cu
->producer_is_gcc_lt_4_3
;
9064 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
9065 const char **name
, const char **comp_dir
)
9067 /* Find the filename. Do not use dwarf2_name here, since the filename
9068 is not a source language identifier. */
9069 *name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
9070 *comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
9072 if (*comp_dir
== NULL
9073 && producer_is_gcc_lt_4_3 (cu
) && *name
!= NULL
9074 && IS_ABSOLUTE_PATH (*name
))
9076 char *d
= ldirname (*name
);
9080 make_cleanup (xfree
, d
);
9082 if (*comp_dir
!= NULL
)
9084 /* Irix 6.2 native cc prepends <machine>.: to the compilation
9085 directory, get rid of it. */
9086 const char *cp
= strchr (*comp_dir
, ':');
9088 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
9093 *name
= "<unknown>";
9096 /* Handle DW_AT_stmt_list for a compilation unit.
9097 DIE is the DW_TAG_compile_unit die for CU.
9098 COMP_DIR is the compilation directory. LOWPC is passed to
9099 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
9102 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
9103 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
9105 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9106 struct attribute
*attr
;
9107 unsigned int line_offset
;
9108 struct line_header line_header_local
;
9109 hashval_t line_header_local_hash
;
9114 gdb_assert (! cu
->per_cu
->is_debug_types
);
9116 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9120 line_offset
= DW_UNSND (attr
);
9122 /* The line header hash table is only created if needed (it exists to
9123 prevent redundant reading of the line table for partial_units).
9124 If we're given a partial_unit, we'll need it. If we're given a
9125 compile_unit, then use the line header hash table if it's already
9126 created, but don't create one just yet. */
9128 if (dwarf2_per_objfile
->line_header_hash
== NULL
9129 && die
->tag
== DW_TAG_partial_unit
)
9131 dwarf2_per_objfile
->line_header_hash
9132 = htab_create_alloc_ex (127, line_header_hash_voidp
,
9133 line_header_eq_voidp
,
9134 free_line_header_voidp
,
9135 &objfile
->objfile_obstack
,
9136 hashtab_obstack_allocate
,
9137 dummy_obstack_deallocate
);
9140 line_header_local
.offset
.sect_off
= line_offset
;
9141 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
9142 line_header_local_hash
= line_header_hash (&line_header_local
);
9143 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
9145 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9147 line_header_local_hash
, NO_INSERT
);
9149 /* For DW_TAG_compile_unit we need info like symtab::linetable which
9150 is not present in *SLOT (since if there is something in *SLOT then
9151 it will be for a partial_unit). */
9152 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
9154 gdb_assert (*slot
!= NULL
);
9155 cu
->line_header
= (struct line_header
*) *slot
;
9160 /* dwarf_decode_line_header does not yet provide sufficient information.
9161 We always have to call also dwarf_decode_lines for it. */
9162 cu
->line_header
= dwarf_decode_line_header (line_offset
, cu
);
9163 if (cu
->line_header
== NULL
)
9166 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
9170 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9172 line_header_local_hash
, INSERT
);
9173 gdb_assert (slot
!= NULL
);
9175 if (slot
!= NULL
&& *slot
== NULL
)
9177 /* This newly decoded line number information unit will be owned
9178 by line_header_hash hash table. */
9179 *slot
= cu
->line_header
;
9183 /* We cannot free any current entry in (*slot) as that struct line_header
9184 may be already used by multiple CUs. Create only temporary decoded
9185 line_header for this CU - it may happen at most once for each line
9186 number information unit. And if we're not using line_header_hash
9187 then this is what we want as well. */
9188 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
9189 make_cleanup (free_cu_line_header
, cu
);
9191 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
9192 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
9196 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
9199 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9201 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9202 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9203 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
9204 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
9205 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
9206 struct attribute
*attr
;
9207 const char *name
= NULL
;
9208 const char *comp_dir
= NULL
;
9209 struct die_info
*child_die
;
9212 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9214 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
9216 /* If we didn't find a lowpc, set it to highpc to avoid complaints
9217 from finish_block. */
9218 if (lowpc
== ((CORE_ADDR
) -1))
9220 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
9222 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
9224 prepare_one_comp_unit (cu
, die
, cu
->language
);
9226 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
9227 standardised yet. As a workaround for the language detection we fall
9228 back to the DW_AT_producer string. */
9229 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
9230 cu
->language
= language_opencl
;
9232 /* Similar hack for Go. */
9233 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
9234 set_cu_language (DW_LANG_Go
, cu
);
9236 dwarf2_start_symtab (cu
, name
, comp_dir
, lowpc
);
9238 /* Decode line number information if present. We do this before
9239 processing child DIEs, so that the line header table is available
9240 for DW_AT_decl_file. */
9241 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, lowpc
);
9243 /* Process all dies in compilation unit. */
9244 if (die
->child
!= NULL
)
9246 child_die
= die
->child
;
9247 while (child_die
&& child_die
->tag
)
9249 process_die (child_die
, cu
);
9250 child_die
= sibling_die (child_die
);
9254 /* Decode macro information, if present. Dwarf 2 macro information
9255 refers to information in the line number info statement program
9256 header, so we can only read it if we've read the header
9258 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
9259 if (attr
&& cu
->line_header
)
9261 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
9262 complaint (&symfile_complaints
,
9263 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
9265 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
9269 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
9270 if (attr
&& cu
->line_header
)
9272 unsigned int macro_offset
= DW_UNSND (attr
);
9274 dwarf_decode_macros (cu
, macro_offset
, 0);
9278 do_cleanups (back_to
);
9281 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
9282 Create the set of symtabs used by this TU, or if this TU is sharing
9283 symtabs with another TU and the symtabs have already been created
9284 then restore those symtabs in the line header.
9285 We don't need the pc/line-number mapping for type units. */
9288 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
9290 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
9291 struct type_unit_group
*tu_group
;
9293 struct line_header
*lh
;
9294 struct attribute
*attr
;
9295 unsigned int i
, line_offset
;
9296 struct signatured_type
*sig_type
;
9298 gdb_assert (per_cu
->is_debug_types
);
9299 sig_type
= (struct signatured_type
*) per_cu
;
9301 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9303 /* If we're using .gdb_index (includes -readnow) then
9304 per_cu->type_unit_group may not have been set up yet. */
9305 if (sig_type
->type_unit_group
== NULL
)
9306 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
9307 tu_group
= sig_type
->type_unit_group
;
9309 /* If we've already processed this stmt_list there's no real need to
9310 do it again, we could fake it and just recreate the part we need
9311 (file name,index -> symtab mapping). If data shows this optimization
9312 is useful we can do it then. */
9313 first_time
= tu_group
->compunit_symtab
== NULL
;
9315 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9320 line_offset
= DW_UNSND (attr
);
9321 lh
= dwarf_decode_line_header (line_offset
, cu
);
9326 dwarf2_start_symtab (cu
, "", NULL
, 0);
9329 gdb_assert (tu_group
->symtabs
== NULL
);
9330 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9335 cu
->line_header
= lh
;
9336 make_cleanup (free_cu_line_header
, cu
);
9340 struct compunit_symtab
*cust
= dwarf2_start_symtab (cu
, "", NULL
, 0);
9342 /* Note: We don't assign tu_group->compunit_symtab yet because we're
9343 still initializing it, and our caller (a few levels up)
9344 process_full_type_unit still needs to know if this is the first
9347 tu_group
->num_symtabs
= lh
->num_file_names
;
9348 tu_group
->symtabs
= XNEWVEC (struct symtab
*, lh
->num_file_names
);
9350 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9352 const char *dir
= NULL
;
9353 struct file_entry
*fe
= &lh
->file_names
[i
];
9355 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
9356 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9357 dwarf2_start_subfile (fe
->name
, dir
);
9359 if (current_subfile
->symtab
== NULL
)
9361 /* NOTE: start_subfile will recognize when it's been passed
9362 a file it has already seen. So we can't assume there's a
9363 simple mapping from lh->file_names to subfiles, plus
9364 lh->file_names may contain dups. */
9365 current_subfile
->symtab
9366 = allocate_symtab (cust
, current_subfile
->name
);
9369 fe
->symtab
= current_subfile
->symtab
;
9370 tu_group
->symtabs
[i
] = fe
->symtab
;
9375 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9377 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9379 struct file_entry
*fe
= &lh
->file_names
[i
];
9381 fe
->symtab
= tu_group
->symtabs
[i
];
9385 /* The main symtab is allocated last. Type units don't have DW_AT_name
9386 so they don't have a "real" (so to speak) symtab anyway.
9387 There is later code that will assign the main symtab to all symbols
9388 that don't have one. We need to handle the case of a symbol with a
9389 missing symtab (DW_AT_decl_file) anyway. */
9392 /* Process DW_TAG_type_unit.
9393 For TUs we want to skip the first top level sibling if it's not the
9394 actual type being defined by this TU. In this case the first top
9395 level sibling is there to provide context only. */
9398 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9400 struct die_info
*child_die
;
9402 prepare_one_comp_unit (cu
, die
, language_minimal
);
9404 /* Initialize (or reinitialize) the machinery for building symtabs.
9405 We do this before processing child DIEs, so that the line header table
9406 is available for DW_AT_decl_file. */
9407 setup_type_unit_groups (die
, cu
);
9409 if (die
->child
!= NULL
)
9411 child_die
= die
->child
;
9412 while (child_die
&& child_die
->tag
)
9414 process_die (child_die
, cu
);
9415 child_die
= sibling_die (child_die
);
9422 http://gcc.gnu.org/wiki/DebugFission
9423 http://gcc.gnu.org/wiki/DebugFissionDWP
9425 To simplify handling of both DWO files ("object" files with the DWARF info)
9426 and DWP files (a file with the DWOs packaged up into one file), we treat
9427 DWP files as having a collection of virtual DWO files. */
9430 hash_dwo_file (const void *item
)
9432 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
9435 hash
= htab_hash_string (dwo_file
->dwo_name
);
9436 if (dwo_file
->comp_dir
!= NULL
)
9437 hash
+= htab_hash_string (dwo_file
->comp_dir
);
9442 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
9444 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
9445 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
9447 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
9449 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
9450 return lhs
->comp_dir
== rhs
->comp_dir
;
9451 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
9454 /* Allocate a hash table for DWO files. */
9457 allocate_dwo_file_hash_table (void)
9459 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9461 return htab_create_alloc_ex (41,
9465 &objfile
->objfile_obstack
,
9466 hashtab_obstack_allocate
,
9467 dummy_obstack_deallocate
);
9470 /* Lookup DWO file DWO_NAME. */
9473 lookup_dwo_file_slot (const char *dwo_name
, const char *comp_dir
)
9475 struct dwo_file find_entry
;
9478 if (dwarf2_per_objfile
->dwo_files
== NULL
)
9479 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
9481 memset (&find_entry
, 0, sizeof (find_entry
));
9482 find_entry
.dwo_name
= dwo_name
;
9483 find_entry
.comp_dir
= comp_dir
;
9484 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
9490 hash_dwo_unit (const void *item
)
9492 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
9494 /* This drops the top 32 bits of the id, but is ok for a hash. */
9495 return dwo_unit
->signature
;
9499 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
9501 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
9502 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
9504 /* The signature is assumed to be unique within the DWO file.
9505 So while object file CU dwo_id's always have the value zero,
9506 that's OK, assuming each object file DWO file has only one CU,
9507 and that's the rule for now. */
9508 return lhs
->signature
== rhs
->signature
;
9511 /* Allocate a hash table for DWO CUs,TUs.
9512 There is one of these tables for each of CUs,TUs for each DWO file. */
9515 allocate_dwo_unit_table (struct objfile
*objfile
)
9517 /* Start out with a pretty small number.
9518 Generally DWO files contain only one CU and maybe some TUs. */
9519 return htab_create_alloc_ex (3,
9523 &objfile
->objfile_obstack
,
9524 hashtab_obstack_allocate
,
9525 dummy_obstack_deallocate
);
9528 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9530 struct create_dwo_cu_data
9532 struct dwo_file
*dwo_file
;
9533 struct dwo_unit dwo_unit
;
9536 /* die_reader_func for create_dwo_cu. */
9539 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
9540 const gdb_byte
*info_ptr
,
9541 struct die_info
*comp_unit_die
,
9545 struct dwarf2_cu
*cu
= reader
->cu
;
9546 sect_offset offset
= cu
->per_cu
->offset
;
9547 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
9548 struct create_dwo_cu_data
*data
= (struct create_dwo_cu_data
*) datap
;
9549 struct dwo_file
*dwo_file
= data
->dwo_file
;
9550 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
9551 struct attribute
*attr
;
9553 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
9556 complaint (&symfile_complaints
,
9557 _("Dwarf Error: debug entry at offset 0x%x is missing"
9558 " its dwo_id [in module %s]"),
9559 offset
.sect_off
, dwo_file
->dwo_name
);
9563 dwo_unit
->dwo_file
= dwo_file
;
9564 dwo_unit
->signature
= DW_UNSND (attr
);
9565 dwo_unit
->section
= section
;
9566 dwo_unit
->offset
= offset
;
9567 dwo_unit
->length
= cu
->per_cu
->length
;
9569 if (dwarf_read_debug
)
9570 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id %s\n",
9571 offset
.sect_off
, hex_string (dwo_unit
->signature
));
9574 /* Create the dwo_unit for the lone CU in DWO_FILE.
9575 Note: This function processes DWO files only, not DWP files. */
9577 static struct dwo_unit
*
9578 create_dwo_cu (struct dwo_file
*dwo_file
)
9580 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9581 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
9582 const gdb_byte
*info_ptr
, *end_ptr
;
9583 struct create_dwo_cu_data create_dwo_cu_data
;
9584 struct dwo_unit
*dwo_unit
;
9586 dwarf2_read_section (objfile
, section
);
9587 info_ptr
= section
->buffer
;
9589 if (info_ptr
== NULL
)
9592 if (dwarf_read_debug
)
9594 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
9595 get_section_name (section
),
9596 get_section_file_name (section
));
9599 create_dwo_cu_data
.dwo_file
= dwo_file
;
9602 end_ptr
= info_ptr
+ section
->size
;
9603 while (info_ptr
< end_ptr
)
9605 struct dwarf2_per_cu_data per_cu
;
9607 memset (&create_dwo_cu_data
.dwo_unit
, 0,
9608 sizeof (create_dwo_cu_data
.dwo_unit
));
9609 memset (&per_cu
, 0, sizeof (per_cu
));
9610 per_cu
.objfile
= objfile
;
9611 per_cu
.is_debug_types
= 0;
9612 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
9613 per_cu
.section
= section
;
9615 init_cutu_and_read_dies_no_follow (&per_cu
, dwo_file
,
9616 create_dwo_cu_reader
,
9617 &create_dwo_cu_data
);
9619 if (create_dwo_cu_data
.dwo_unit
.dwo_file
!= NULL
)
9621 /* If we've already found one, complain. We only support one
9622 because having more than one requires hacking the dwo_name of
9623 each to match, which is highly unlikely to happen. */
9624 if (dwo_unit
!= NULL
)
9626 complaint (&symfile_complaints
,
9627 _("Multiple CUs in DWO file %s [in module %s]"),
9628 dwo_file
->dwo_name
, objfile_name (objfile
));
9632 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
9633 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
9636 info_ptr
+= per_cu
.length
;
9642 /* DWP file .debug_{cu,tu}_index section format:
9643 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9647 Both index sections have the same format, and serve to map a 64-bit
9648 signature to a set of section numbers. Each section begins with a header,
9649 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9650 indexes, and a pool of 32-bit section numbers. The index sections will be
9651 aligned at 8-byte boundaries in the file.
9653 The index section header consists of:
9655 V, 32 bit version number
9657 N, 32 bit number of compilation units or type units in the index
9658 M, 32 bit number of slots in the hash table
9660 Numbers are recorded using the byte order of the application binary.
9662 The hash table begins at offset 16 in the section, and consists of an array
9663 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9664 order of the application binary). Unused slots in the hash table are 0.
9665 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9667 The parallel table begins immediately after the hash table
9668 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9669 array of 32-bit indexes (using the byte order of the application binary),
9670 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9671 table contains a 32-bit index into the pool of section numbers. For unused
9672 hash table slots, the corresponding entry in the parallel table will be 0.
9674 The pool of section numbers begins immediately following the hash table
9675 (at offset 16 + 12 * M from the beginning of the section). The pool of
9676 section numbers consists of an array of 32-bit words (using the byte order
9677 of the application binary). Each item in the array is indexed starting
9678 from 0. The hash table entry provides the index of the first section
9679 number in the set. Additional section numbers in the set follow, and the
9680 set is terminated by a 0 entry (section number 0 is not used in ELF).
9682 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9683 section must be the first entry in the set, and the .debug_abbrev.dwo must
9684 be the second entry. Other members of the set may follow in any order.
9690 DWP Version 2 combines all the .debug_info, etc. sections into one,
9691 and the entries in the index tables are now offsets into these sections.
9692 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9695 Index Section Contents:
9697 Hash Table of Signatures dwp_hash_table.hash_table
9698 Parallel Table of Indices dwp_hash_table.unit_table
9699 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9700 Table of Section Sizes dwp_hash_table.v2.sizes
9702 The index section header consists of:
9704 V, 32 bit version number
9705 L, 32 bit number of columns in the table of section offsets
9706 N, 32 bit number of compilation units or type units in the index
9707 M, 32 bit number of slots in the hash table
9709 Numbers are recorded using the byte order of the application binary.
9711 The hash table has the same format as version 1.
9712 The parallel table of indices has the same format as version 1,
9713 except that the entries are origin-1 indices into the table of sections
9714 offsets and the table of section sizes.
9716 The table of offsets begins immediately following the parallel table
9717 (at offset 16 + 12 * M from the beginning of the section). The table is
9718 a two-dimensional array of 32-bit words (using the byte order of the
9719 application binary), with L columns and N+1 rows, in row-major order.
9720 Each row in the array is indexed starting from 0. The first row provides
9721 a key to the remaining rows: each column in this row provides an identifier
9722 for a debug section, and the offsets in the same column of subsequent rows
9723 refer to that section. The section identifiers are:
9725 DW_SECT_INFO 1 .debug_info.dwo
9726 DW_SECT_TYPES 2 .debug_types.dwo
9727 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9728 DW_SECT_LINE 4 .debug_line.dwo
9729 DW_SECT_LOC 5 .debug_loc.dwo
9730 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9731 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9732 DW_SECT_MACRO 8 .debug_macro.dwo
9734 The offsets provided by the CU and TU index sections are the base offsets
9735 for the contributions made by each CU or TU to the corresponding section
9736 in the package file. Each CU and TU header contains an abbrev_offset
9737 field, used to find the abbreviations table for that CU or TU within the
9738 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9739 be interpreted as relative to the base offset given in the index section.
9740 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9741 should be interpreted as relative to the base offset for .debug_line.dwo,
9742 and offsets into other debug sections obtained from DWARF attributes should
9743 also be interpreted as relative to the corresponding base offset.
9745 The table of sizes begins immediately following the table of offsets.
9746 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9747 with L columns and N rows, in row-major order. Each row in the array is
9748 indexed starting from 1 (row 0 is shared by the two tables).
9752 Hash table lookup is handled the same in version 1 and 2:
9754 We assume that N and M will not exceed 2^32 - 1.
9755 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9757 Given a 64-bit compilation unit signature or a type signature S, an entry
9758 in the hash table is located as follows:
9760 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9761 the low-order k bits all set to 1.
9763 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9765 3) If the hash table entry at index H matches the signature, use that
9766 entry. If the hash table entry at index H is unused (all zeroes),
9767 terminate the search: the signature is not present in the table.
9769 4) Let H = (H + H') modulo M. Repeat at Step 3.
9771 Because M > N and H' and M are relatively prime, the search is guaranteed
9772 to stop at an unused slot or find the match. */
9774 /* Create a hash table to map DWO IDs to their CU/TU entry in
9775 .debug_{info,types}.dwo in DWP_FILE.
9776 Returns NULL if there isn't one.
9777 Note: This function processes DWP files only, not DWO files. */
9779 static struct dwp_hash_table
*
9780 create_dwp_hash_table (struct dwp_file
*dwp_file
, int is_debug_types
)
9782 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9783 bfd
*dbfd
= dwp_file
->dbfd
;
9784 const gdb_byte
*index_ptr
, *index_end
;
9785 struct dwarf2_section_info
*index
;
9786 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
9787 struct dwp_hash_table
*htab
;
9790 index
= &dwp_file
->sections
.tu_index
;
9792 index
= &dwp_file
->sections
.cu_index
;
9794 if (dwarf2_section_empty_p (index
))
9796 dwarf2_read_section (objfile
, index
);
9798 index_ptr
= index
->buffer
;
9799 index_end
= index_ptr
+ index
->size
;
9801 version
= read_4_bytes (dbfd
, index_ptr
);
9804 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
9808 nr_units
= read_4_bytes (dbfd
, index_ptr
);
9810 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
9813 if (version
!= 1 && version
!= 2)
9815 error (_("Dwarf Error: unsupported DWP file version (%s)"
9817 pulongest (version
), dwp_file
->name
);
9819 if (nr_slots
!= (nr_slots
& -nr_slots
))
9821 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9822 " is not power of 2 [in module %s]"),
9823 pulongest (nr_slots
), dwp_file
->name
);
9826 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
9827 htab
->version
= version
;
9828 htab
->nr_columns
= nr_columns
;
9829 htab
->nr_units
= nr_units
;
9830 htab
->nr_slots
= nr_slots
;
9831 htab
->hash_table
= index_ptr
;
9832 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
9834 /* Exit early if the table is empty. */
9835 if (nr_slots
== 0 || nr_units
== 0
9836 || (version
== 2 && nr_columns
== 0))
9838 /* All must be zero. */
9839 if (nr_slots
!= 0 || nr_units
!= 0
9840 || (version
== 2 && nr_columns
!= 0))
9842 complaint (&symfile_complaints
,
9843 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9844 " all zero [in modules %s]"),
9852 htab
->section_pool
.v1
.indices
=
9853 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9854 /* It's harder to decide whether the section is too small in v1.
9855 V1 is deprecated anyway so we punt. */
9859 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9860 int *ids
= htab
->section_pool
.v2
.section_ids
;
9861 /* Reverse map for error checking. */
9862 int ids_seen
[DW_SECT_MAX
+ 1];
9867 error (_("Dwarf Error: bad DWP hash table, too few columns"
9868 " in section table [in module %s]"),
9871 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
9873 error (_("Dwarf Error: bad DWP hash table, too many columns"
9874 " in section table [in module %s]"),
9877 memset (ids
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9878 memset (ids_seen
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9879 for (i
= 0; i
< nr_columns
; ++i
)
9881 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
9883 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
9885 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9886 " in section table [in module %s]"),
9887 id
, dwp_file
->name
);
9889 if (ids_seen
[id
] != -1)
9891 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9892 " id %d in section table [in module %s]"),
9893 id
, dwp_file
->name
);
9898 /* Must have exactly one info or types section. */
9899 if (((ids_seen
[DW_SECT_INFO
] != -1)
9900 + (ids_seen
[DW_SECT_TYPES
] != -1))
9903 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9904 " DWO info/types section [in module %s]"),
9907 /* Must have an abbrev section. */
9908 if (ids_seen
[DW_SECT_ABBREV
] == -1)
9910 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9911 " section [in module %s]"),
9914 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
9915 htab
->section_pool
.v2
.sizes
=
9916 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
9917 * nr_units
* nr_columns
);
9918 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
9919 * nr_units
* nr_columns
))
9922 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9931 /* Update SECTIONS with the data from SECTP.
9933 This function is like the other "locate" section routines that are
9934 passed to bfd_map_over_sections, but in this context the sections to
9935 read comes from the DWP V1 hash table, not the full ELF section table.
9937 The result is non-zero for success, or zero if an error was found. */
9940 locate_v1_virtual_dwo_sections (asection
*sectp
,
9941 struct virtual_v1_dwo_sections
*sections
)
9943 const struct dwop_section_names
*names
= &dwop_section_names
;
9945 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
9947 /* There can be only one. */
9948 if (sections
->abbrev
.s
.section
!= NULL
)
9950 sections
->abbrev
.s
.section
= sectp
;
9951 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
9953 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
9954 || section_is_p (sectp
->name
, &names
->types_dwo
))
9956 /* There can be only one. */
9957 if (sections
->info_or_types
.s
.section
!= NULL
)
9959 sections
->info_or_types
.s
.section
= sectp
;
9960 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
9962 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
9964 /* There can be only one. */
9965 if (sections
->line
.s
.section
!= NULL
)
9967 sections
->line
.s
.section
= sectp
;
9968 sections
->line
.size
= bfd_get_section_size (sectp
);
9970 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
9972 /* There can be only one. */
9973 if (sections
->loc
.s
.section
!= NULL
)
9975 sections
->loc
.s
.section
= sectp
;
9976 sections
->loc
.size
= bfd_get_section_size (sectp
);
9978 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
9980 /* There can be only one. */
9981 if (sections
->macinfo
.s
.section
!= NULL
)
9983 sections
->macinfo
.s
.section
= sectp
;
9984 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
9986 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
9988 /* There can be only one. */
9989 if (sections
->macro
.s
.section
!= NULL
)
9991 sections
->macro
.s
.section
= sectp
;
9992 sections
->macro
.size
= bfd_get_section_size (sectp
);
9994 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
9996 /* There can be only one. */
9997 if (sections
->str_offsets
.s
.section
!= NULL
)
9999 sections
->str_offsets
.s
.section
= sectp
;
10000 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
10004 /* No other kind of section is valid. */
10011 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10012 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10013 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10014 This is for DWP version 1 files. */
10016 static struct dwo_unit
*
10017 create_dwo_unit_in_dwp_v1 (struct dwp_file
*dwp_file
,
10018 uint32_t unit_index
,
10019 const char *comp_dir
,
10020 ULONGEST signature
, int is_debug_types
)
10022 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10023 const struct dwp_hash_table
*dwp_htab
=
10024 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10025 bfd
*dbfd
= dwp_file
->dbfd
;
10026 const char *kind
= is_debug_types
? "TU" : "CU";
10027 struct dwo_file
*dwo_file
;
10028 struct dwo_unit
*dwo_unit
;
10029 struct virtual_v1_dwo_sections sections
;
10030 void **dwo_file_slot
;
10031 char *virtual_dwo_name
;
10032 struct cleanup
*cleanups
;
10035 gdb_assert (dwp_file
->version
== 1);
10037 if (dwarf_read_debug
)
10039 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
10041 pulongest (unit_index
), hex_string (signature
),
10045 /* Fetch the sections of this DWO unit.
10046 Put a limit on the number of sections we look for so that bad data
10047 doesn't cause us to loop forever. */
10049 #define MAX_NR_V1_DWO_SECTIONS \
10050 (1 /* .debug_info or .debug_types */ \
10051 + 1 /* .debug_abbrev */ \
10052 + 1 /* .debug_line */ \
10053 + 1 /* .debug_loc */ \
10054 + 1 /* .debug_str_offsets */ \
10055 + 1 /* .debug_macro or .debug_macinfo */ \
10056 + 1 /* trailing zero */)
10058 memset (§ions
, 0, sizeof (sections
));
10059 cleanups
= make_cleanup (null_cleanup
, 0);
10061 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
10064 uint32_t section_nr
=
10065 read_4_bytes (dbfd
,
10066 dwp_htab
->section_pool
.v1
.indices
10067 + (unit_index
+ i
) * sizeof (uint32_t));
10069 if (section_nr
== 0)
10071 if (section_nr
>= dwp_file
->num_sections
)
10073 error (_("Dwarf Error: bad DWP hash table, section number too large"
10074 " [in module %s]"),
10078 sectp
= dwp_file
->elf_sections
[section_nr
];
10079 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
10081 error (_("Dwarf Error: bad DWP hash table, invalid section found"
10082 " [in module %s]"),
10088 || dwarf2_section_empty_p (§ions
.info_or_types
)
10089 || dwarf2_section_empty_p (§ions
.abbrev
))
10091 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
10092 " [in module %s]"),
10095 if (i
== MAX_NR_V1_DWO_SECTIONS
)
10097 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
10098 " [in module %s]"),
10102 /* It's easier for the rest of the code if we fake a struct dwo_file and
10103 have dwo_unit "live" in that. At least for now.
10105 The DWP file can be made up of a random collection of CUs and TUs.
10106 However, for each CU + set of TUs that came from the same original DWO
10107 file, we can combine them back into a virtual DWO file to save space
10108 (fewer struct dwo_file objects to allocate). Remember that for really
10109 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10112 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
10113 get_section_id (§ions
.abbrev
),
10114 get_section_id (§ions
.line
),
10115 get_section_id (§ions
.loc
),
10116 get_section_id (§ions
.str_offsets
));
10117 make_cleanup (xfree
, virtual_dwo_name
);
10118 /* Can we use an existing virtual DWO file? */
10119 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10120 /* Create one if necessary. */
10121 if (*dwo_file_slot
== NULL
)
10123 if (dwarf_read_debug
)
10125 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10128 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10130 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
10132 strlen (virtual_dwo_name
));
10133 dwo_file
->comp_dir
= comp_dir
;
10134 dwo_file
->sections
.abbrev
= sections
.abbrev
;
10135 dwo_file
->sections
.line
= sections
.line
;
10136 dwo_file
->sections
.loc
= sections
.loc
;
10137 dwo_file
->sections
.macinfo
= sections
.macinfo
;
10138 dwo_file
->sections
.macro
= sections
.macro
;
10139 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
10140 /* The "str" section is global to the entire DWP file. */
10141 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10142 /* The info or types section is assigned below to dwo_unit,
10143 there's no need to record it in dwo_file.
10144 Also, we can't simply record type sections in dwo_file because
10145 we record a pointer into the vector in dwo_unit. As we collect more
10146 types we'll grow the vector and eventually have to reallocate space
10147 for it, invalidating all copies of pointers into the previous
10149 *dwo_file_slot
= dwo_file
;
10153 if (dwarf_read_debug
)
10155 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10158 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
10160 do_cleanups (cleanups
);
10162 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10163 dwo_unit
->dwo_file
= dwo_file
;
10164 dwo_unit
->signature
= signature
;
10165 dwo_unit
->section
=
10166 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
10167 *dwo_unit
->section
= sections
.info_or_types
;
10168 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10173 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
10174 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
10175 piece within that section used by a TU/CU, return a virtual section
10176 of just that piece. */
10178 static struct dwarf2_section_info
10179 create_dwp_v2_section (struct dwarf2_section_info
*section
,
10180 bfd_size_type offset
, bfd_size_type size
)
10182 struct dwarf2_section_info result
;
10185 gdb_assert (section
!= NULL
);
10186 gdb_assert (!section
->is_virtual
);
10188 memset (&result
, 0, sizeof (result
));
10189 result
.s
.containing_section
= section
;
10190 result
.is_virtual
= 1;
10195 sectp
= get_section_bfd_section (section
);
10197 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
10198 bounds of the real section. This is a pretty-rare event, so just
10199 flag an error (easier) instead of a warning and trying to cope. */
10201 || offset
+ size
> bfd_get_section_size (sectp
))
10203 bfd
*abfd
= sectp
->owner
;
10205 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
10206 " in section %s [in module %s]"),
10207 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
10208 objfile_name (dwarf2_per_objfile
->objfile
));
10211 result
.virtual_offset
= offset
;
10212 result
.size
= size
;
10216 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10217 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10218 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10219 This is for DWP version 2 files. */
10221 static struct dwo_unit
*
10222 create_dwo_unit_in_dwp_v2 (struct dwp_file
*dwp_file
,
10223 uint32_t unit_index
,
10224 const char *comp_dir
,
10225 ULONGEST signature
, int is_debug_types
)
10227 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10228 const struct dwp_hash_table
*dwp_htab
=
10229 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10230 bfd
*dbfd
= dwp_file
->dbfd
;
10231 const char *kind
= is_debug_types
? "TU" : "CU";
10232 struct dwo_file
*dwo_file
;
10233 struct dwo_unit
*dwo_unit
;
10234 struct virtual_v2_dwo_sections sections
;
10235 void **dwo_file_slot
;
10236 char *virtual_dwo_name
;
10237 struct cleanup
*cleanups
;
10240 gdb_assert (dwp_file
->version
== 2);
10242 if (dwarf_read_debug
)
10244 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
10246 pulongest (unit_index
), hex_string (signature
),
10250 /* Fetch the section offsets of this DWO unit. */
10252 memset (§ions
, 0, sizeof (sections
));
10253 cleanups
= make_cleanup (null_cleanup
, 0);
10255 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
10257 uint32_t offset
= read_4_bytes (dbfd
,
10258 dwp_htab
->section_pool
.v2
.offsets
10259 + (((unit_index
- 1) * dwp_htab
->nr_columns
10261 * sizeof (uint32_t)));
10262 uint32_t size
= read_4_bytes (dbfd
,
10263 dwp_htab
->section_pool
.v2
.sizes
10264 + (((unit_index
- 1) * dwp_htab
->nr_columns
10266 * sizeof (uint32_t)));
10268 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
10271 case DW_SECT_TYPES
:
10272 sections
.info_or_types_offset
= offset
;
10273 sections
.info_or_types_size
= size
;
10275 case DW_SECT_ABBREV
:
10276 sections
.abbrev_offset
= offset
;
10277 sections
.abbrev_size
= size
;
10280 sections
.line_offset
= offset
;
10281 sections
.line_size
= size
;
10284 sections
.loc_offset
= offset
;
10285 sections
.loc_size
= size
;
10287 case DW_SECT_STR_OFFSETS
:
10288 sections
.str_offsets_offset
= offset
;
10289 sections
.str_offsets_size
= size
;
10291 case DW_SECT_MACINFO
:
10292 sections
.macinfo_offset
= offset
;
10293 sections
.macinfo_size
= size
;
10295 case DW_SECT_MACRO
:
10296 sections
.macro_offset
= offset
;
10297 sections
.macro_size
= size
;
10302 /* It's easier for the rest of the code if we fake a struct dwo_file and
10303 have dwo_unit "live" in that. At least for now.
10305 The DWP file can be made up of a random collection of CUs and TUs.
10306 However, for each CU + set of TUs that came from the same original DWO
10307 file, we can combine them back into a virtual DWO file to save space
10308 (fewer struct dwo_file objects to allocate). Remember that for really
10309 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10312 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10313 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
10314 (long) (sections
.line_size
? sections
.line_offset
: 0),
10315 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
10316 (long) (sections
.str_offsets_size
10317 ? sections
.str_offsets_offset
: 0));
10318 make_cleanup (xfree
, virtual_dwo_name
);
10319 /* Can we use an existing virtual DWO file? */
10320 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10321 /* Create one if necessary. */
10322 if (*dwo_file_slot
== NULL
)
10324 if (dwarf_read_debug
)
10326 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10329 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10331 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
10333 strlen (virtual_dwo_name
));
10334 dwo_file
->comp_dir
= comp_dir
;
10335 dwo_file
->sections
.abbrev
=
10336 create_dwp_v2_section (&dwp_file
->sections
.abbrev
,
10337 sections
.abbrev_offset
, sections
.abbrev_size
);
10338 dwo_file
->sections
.line
=
10339 create_dwp_v2_section (&dwp_file
->sections
.line
,
10340 sections
.line_offset
, sections
.line_size
);
10341 dwo_file
->sections
.loc
=
10342 create_dwp_v2_section (&dwp_file
->sections
.loc
,
10343 sections
.loc_offset
, sections
.loc_size
);
10344 dwo_file
->sections
.macinfo
=
10345 create_dwp_v2_section (&dwp_file
->sections
.macinfo
,
10346 sections
.macinfo_offset
, sections
.macinfo_size
);
10347 dwo_file
->sections
.macro
=
10348 create_dwp_v2_section (&dwp_file
->sections
.macro
,
10349 sections
.macro_offset
, sections
.macro_size
);
10350 dwo_file
->sections
.str_offsets
=
10351 create_dwp_v2_section (&dwp_file
->sections
.str_offsets
,
10352 sections
.str_offsets_offset
,
10353 sections
.str_offsets_size
);
10354 /* The "str" section is global to the entire DWP file. */
10355 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10356 /* The info or types section is assigned below to dwo_unit,
10357 there's no need to record it in dwo_file.
10358 Also, we can't simply record type sections in dwo_file because
10359 we record a pointer into the vector in dwo_unit. As we collect more
10360 types we'll grow the vector and eventually have to reallocate space
10361 for it, invalidating all copies of pointers into the previous
10363 *dwo_file_slot
= dwo_file
;
10367 if (dwarf_read_debug
)
10369 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10372 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
10374 do_cleanups (cleanups
);
10376 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10377 dwo_unit
->dwo_file
= dwo_file
;
10378 dwo_unit
->signature
= signature
;
10379 dwo_unit
->section
=
10380 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
10381 *dwo_unit
->section
= create_dwp_v2_section (is_debug_types
10382 ? &dwp_file
->sections
.types
10383 : &dwp_file
->sections
.info
,
10384 sections
.info_or_types_offset
,
10385 sections
.info_or_types_size
);
10386 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10391 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10392 Returns NULL if the signature isn't found. */
10394 static struct dwo_unit
*
10395 lookup_dwo_unit_in_dwp (struct dwp_file
*dwp_file
, const char *comp_dir
,
10396 ULONGEST signature
, int is_debug_types
)
10398 const struct dwp_hash_table
*dwp_htab
=
10399 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10400 bfd
*dbfd
= dwp_file
->dbfd
;
10401 uint32_t mask
= dwp_htab
->nr_slots
- 1;
10402 uint32_t hash
= signature
& mask
;
10403 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
10406 struct dwo_unit find_dwo_cu
;
10408 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
10409 find_dwo_cu
.signature
= signature
;
10410 slot
= htab_find_slot (is_debug_types
10411 ? dwp_file
->loaded_tus
10412 : dwp_file
->loaded_cus
,
10413 &find_dwo_cu
, INSERT
);
10416 return (struct dwo_unit
*) *slot
;
10418 /* Use a for loop so that we don't loop forever on bad debug info. */
10419 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
10421 ULONGEST signature_in_table
;
10423 signature_in_table
=
10424 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
10425 if (signature_in_table
== signature
)
10427 uint32_t unit_index
=
10428 read_4_bytes (dbfd
,
10429 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
10431 if (dwp_file
->version
== 1)
10433 *slot
= create_dwo_unit_in_dwp_v1 (dwp_file
, unit_index
,
10434 comp_dir
, signature
,
10439 *slot
= create_dwo_unit_in_dwp_v2 (dwp_file
, unit_index
,
10440 comp_dir
, signature
,
10443 return (struct dwo_unit
*) *slot
;
10445 if (signature_in_table
== 0)
10447 hash
= (hash
+ hash2
) & mask
;
10450 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10451 " [in module %s]"),
10455 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10456 Open the file specified by FILE_NAME and hand it off to BFD for
10457 preliminary analysis. Return a newly initialized bfd *, which
10458 includes a canonicalized copy of FILE_NAME.
10459 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10460 SEARCH_CWD is true if the current directory is to be searched.
10461 It will be searched before debug-file-directory.
10462 If successful, the file is added to the bfd include table of the
10463 objfile's bfd (see gdb_bfd_record_inclusion).
10464 If unable to find/open the file, return NULL.
10465 NOTE: This function is derived from symfile_bfd_open. */
10468 try_open_dwop_file (const char *file_name
, int is_dwp
, int search_cwd
)
10472 char *absolute_name
;
10473 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10474 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10475 to debug_file_directory. */
10477 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
10481 if (*debug_file_directory
!= '\0')
10482 search_path
= concat (".", dirname_separator_string
,
10483 debug_file_directory
, (char *) NULL
);
10485 search_path
= xstrdup (".");
10488 search_path
= xstrdup (debug_file_directory
);
10490 flags
= OPF_RETURN_REALPATH
;
10492 flags
|= OPF_SEARCH_IN_PATH
;
10493 desc
= openp (search_path
, flags
, file_name
,
10494 O_RDONLY
| O_BINARY
, &absolute_name
);
10495 xfree (search_path
);
10499 sym_bfd
= gdb_bfd_open (absolute_name
, gnutarget
, desc
);
10500 xfree (absolute_name
);
10501 if (sym_bfd
== NULL
)
10503 bfd_set_cacheable (sym_bfd
, 1);
10505 if (!bfd_check_format (sym_bfd
, bfd_object
))
10507 gdb_bfd_unref (sym_bfd
); /* This also closes desc. */
10511 /* Success. Record the bfd as having been included by the objfile's bfd.
10512 This is important because things like demangled_names_hash lives in the
10513 objfile's per_bfd space and may have references to things like symbol
10514 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10515 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
);
10520 /* Try to open DWO file FILE_NAME.
10521 COMP_DIR is the DW_AT_comp_dir attribute.
10522 The result is the bfd handle of the file.
10523 If there is a problem finding or opening the file, return NULL.
10524 Upon success, the canonicalized path of the file is stored in the bfd,
10525 same as symfile_bfd_open. */
10528 open_dwo_file (const char *file_name
, const char *comp_dir
)
10532 if (IS_ABSOLUTE_PATH (file_name
))
10533 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 0 /*search_cwd*/);
10535 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10537 if (comp_dir
!= NULL
)
10539 char *path_to_try
= concat (comp_dir
, SLASH_STRING
,
10540 file_name
, (char *) NULL
);
10542 /* NOTE: If comp_dir is a relative path, this will also try the
10543 search path, which seems useful. */
10544 abfd
= try_open_dwop_file (path_to_try
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10545 xfree (path_to_try
);
10550 /* That didn't work, try debug-file-directory, which, despite its name,
10551 is a list of paths. */
10553 if (*debug_file_directory
== '\0')
10556 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10559 /* This function is mapped across the sections and remembers the offset and
10560 size of each of the DWO debugging sections we are interested in. */
10563 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
10565 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
10566 const struct dwop_section_names
*names
= &dwop_section_names
;
10568 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10570 dwo_sections
->abbrev
.s
.section
= sectp
;
10571 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
10573 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10575 dwo_sections
->info
.s
.section
= sectp
;
10576 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
10578 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10580 dwo_sections
->line
.s
.section
= sectp
;
10581 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
10583 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10585 dwo_sections
->loc
.s
.section
= sectp
;
10586 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
10588 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10590 dwo_sections
->macinfo
.s
.section
= sectp
;
10591 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
10593 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10595 dwo_sections
->macro
.s
.section
= sectp
;
10596 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
10598 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
10600 dwo_sections
->str
.s
.section
= sectp
;
10601 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
10603 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10605 dwo_sections
->str_offsets
.s
.section
= sectp
;
10606 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
10608 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10610 struct dwarf2_section_info type_section
;
10612 memset (&type_section
, 0, sizeof (type_section
));
10613 type_section
.s
.section
= sectp
;
10614 type_section
.size
= bfd_get_section_size (sectp
);
10615 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
10620 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10621 by PER_CU. This is for the non-DWP case.
10622 The result is NULL if DWO_NAME can't be found. */
10624 static struct dwo_file
*
10625 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
10626 const char *dwo_name
, const char *comp_dir
)
10628 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10629 struct dwo_file
*dwo_file
;
10631 struct cleanup
*cleanups
;
10633 dbfd
= open_dwo_file (dwo_name
, comp_dir
);
10636 if (dwarf_read_debug
)
10637 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
10640 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10641 dwo_file
->dwo_name
= dwo_name
;
10642 dwo_file
->comp_dir
= comp_dir
;
10643 dwo_file
->dbfd
= dbfd
;
10645 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
10647 bfd_map_over_sections (dbfd
, dwarf2_locate_dwo_sections
, &dwo_file
->sections
);
10649 dwo_file
->cu
= create_dwo_cu (dwo_file
);
10651 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
10652 dwo_file
->sections
.types
);
10654 discard_cleanups (cleanups
);
10656 if (dwarf_read_debug
)
10657 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
10662 /* This function is mapped across the sections and remembers the offset and
10663 size of each of the DWP debugging sections common to version 1 and 2 that
10664 we are interested in. */
10667 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
10668 void *dwp_file_ptr
)
10670 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
10671 const struct dwop_section_names
*names
= &dwop_section_names
;
10672 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10674 /* Record the ELF section number for later lookup: this is what the
10675 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10676 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10677 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10679 /* Look for specific sections that we need. */
10680 if (section_is_p (sectp
->name
, &names
->str_dwo
))
10682 dwp_file
->sections
.str
.s
.section
= sectp
;
10683 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
10685 else if (section_is_p (sectp
->name
, &names
->cu_index
))
10687 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
10688 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
10690 else if (section_is_p (sectp
->name
, &names
->tu_index
))
10692 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
10693 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
10697 /* This function is mapped across the sections and remembers the offset and
10698 size of each of the DWP version 2 debugging sections that we are interested
10699 in. This is split into a separate function because we don't know if we
10700 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10703 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
10705 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
10706 const struct dwop_section_names
*names
= &dwop_section_names
;
10707 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10709 /* Record the ELF section number for later lookup: this is what the
10710 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10711 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10712 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10714 /* Look for specific sections that we need. */
10715 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10717 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
10718 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
10720 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10722 dwp_file
->sections
.info
.s
.section
= sectp
;
10723 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
10725 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10727 dwp_file
->sections
.line
.s
.section
= sectp
;
10728 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
10730 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10732 dwp_file
->sections
.loc
.s
.section
= sectp
;
10733 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
10735 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10737 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
10738 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
10740 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10742 dwp_file
->sections
.macro
.s
.section
= sectp
;
10743 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
10745 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10747 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
10748 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
10750 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10752 dwp_file
->sections
.types
.s
.section
= sectp
;
10753 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
10757 /* Hash function for dwp_file loaded CUs/TUs. */
10760 hash_dwp_loaded_cutus (const void *item
)
10762 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
10764 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10765 return dwo_unit
->signature
;
10768 /* Equality function for dwp_file loaded CUs/TUs. */
10771 eq_dwp_loaded_cutus (const void *a
, const void *b
)
10773 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
10774 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
10776 return dua
->signature
== dub
->signature
;
10779 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10782 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
10784 return htab_create_alloc_ex (3,
10785 hash_dwp_loaded_cutus
,
10786 eq_dwp_loaded_cutus
,
10788 &objfile
->objfile_obstack
,
10789 hashtab_obstack_allocate
,
10790 dummy_obstack_deallocate
);
10793 /* Try to open DWP file FILE_NAME.
10794 The result is the bfd handle of the file.
10795 If there is a problem finding or opening the file, return NULL.
10796 Upon success, the canonicalized path of the file is stored in the bfd,
10797 same as symfile_bfd_open. */
10800 open_dwp_file (const char *file_name
)
10804 abfd
= try_open_dwop_file (file_name
, 1 /*is_dwp*/, 1 /*search_cwd*/);
10808 /* Work around upstream bug 15652.
10809 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10810 [Whether that's a "bug" is debatable, but it is getting in our way.]
10811 We have no real idea where the dwp file is, because gdb's realpath-ing
10812 of the executable's path may have discarded the needed info.
10813 [IWBN if the dwp file name was recorded in the executable, akin to
10814 .gnu_debuglink, but that doesn't exist yet.]
10815 Strip the directory from FILE_NAME and search again. */
10816 if (*debug_file_directory
!= '\0')
10818 /* Don't implicitly search the current directory here.
10819 If the user wants to search "." to handle this case,
10820 it must be added to debug-file-directory. */
10821 return try_open_dwop_file (lbasename (file_name
), 1 /*is_dwp*/,
10828 /* Initialize the use of the DWP file for the current objfile.
10829 By convention the name of the DWP file is ${objfile}.dwp.
10830 The result is NULL if it can't be found. */
10832 static struct dwp_file
*
10833 open_and_init_dwp_file (void)
10835 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10836 struct dwp_file
*dwp_file
;
10839 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, 0);
10841 /* Try to find first .dwp for the binary file before any symbolic links
10844 /* If the objfile is a debug file, find the name of the real binary
10845 file and get the name of dwp file from there. */
10846 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
10848 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
10849 const char *backlink_basename
= lbasename (backlink
->original_name
);
10850 char *debug_dirname
= ldirname (objfile
->original_name
);
10852 make_cleanup (xfree
, debug_dirname
);
10853 dwp_name
= xstrprintf ("%s%s%s.dwp", debug_dirname
,
10854 SLASH_STRING
, backlink_basename
);
10857 dwp_name
= xstrprintf ("%s.dwp", objfile
->original_name
);
10858 make_cleanup (xfree
, dwp_name
);
10860 dbfd
= open_dwp_file (dwp_name
);
10862 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
10864 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10865 dwp_name
= xstrprintf ("%s.dwp", objfile_name (objfile
));
10866 make_cleanup (xfree
, dwp_name
);
10867 dbfd
= open_dwp_file (dwp_name
);
10872 if (dwarf_read_debug
)
10873 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
);
10874 do_cleanups (cleanups
);
10877 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
10878 dwp_file
->name
= bfd_get_filename (dbfd
);
10879 dwp_file
->dbfd
= dbfd
;
10880 do_cleanups (cleanups
);
10882 /* +1: section 0 is unused */
10883 dwp_file
->num_sections
= bfd_count_sections (dbfd
) + 1;
10884 dwp_file
->elf_sections
=
10885 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
10886 dwp_file
->num_sections
, asection
*);
10888 bfd_map_over_sections (dbfd
, dwarf2_locate_common_dwp_sections
, dwp_file
);
10890 dwp_file
->cus
= create_dwp_hash_table (dwp_file
, 0);
10892 dwp_file
->tus
= create_dwp_hash_table (dwp_file
, 1);
10894 /* The DWP file version is stored in the hash table. Oh well. */
10895 if (dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
10897 /* Technically speaking, we should try to limp along, but this is
10898 pretty bizarre. We use pulongest here because that's the established
10899 portability solution (e.g, we cannot use %u for uint32_t). */
10900 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10901 " TU version %s [in DWP file %s]"),
10902 pulongest (dwp_file
->cus
->version
),
10903 pulongest (dwp_file
->tus
->version
), dwp_name
);
10905 dwp_file
->version
= dwp_file
->cus
->version
;
10907 if (dwp_file
->version
== 2)
10908 bfd_map_over_sections (dbfd
, dwarf2_locate_v2_dwp_sections
, dwp_file
);
10910 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
10911 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
10913 if (dwarf_read_debug
)
10915 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
10916 fprintf_unfiltered (gdb_stdlog
,
10917 " %s CUs, %s TUs\n",
10918 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
10919 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
10925 /* Wrapper around open_and_init_dwp_file, only open it once. */
10927 static struct dwp_file
*
10928 get_dwp_file (void)
10930 if (! dwarf2_per_objfile
->dwp_checked
)
10932 dwarf2_per_objfile
->dwp_file
= open_and_init_dwp_file ();
10933 dwarf2_per_objfile
->dwp_checked
= 1;
10935 return dwarf2_per_objfile
->dwp_file
;
10938 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10939 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10940 or in the DWP file for the objfile, referenced by THIS_UNIT.
10941 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10942 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10944 This is called, for example, when wanting to read a variable with a
10945 complex location. Therefore we don't want to do file i/o for every call.
10946 Therefore we don't want to look for a DWO file on every call.
10947 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10948 then we check if we've already seen DWO_NAME, and only THEN do we check
10951 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10952 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10954 static struct dwo_unit
*
10955 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
10956 const char *dwo_name
, const char *comp_dir
,
10957 ULONGEST signature
, int is_debug_types
)
10959 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10960 const char *kind
= is_debug_types
? "TU" : "CU";
10961 void **dwo_file_slot
;
10962 struct dwo_file
*dwo_file
;
10963 struct dwp_file
*dwp_file
;
10965 /* First see if there's a DWP file.
10966 If we have a DWP file but didn't find the DWO inside it, don't
10967 look for the original DWO file. It makes gdb behave differently
10968 depending on whether one is debugging in the build tree. */
10970 dwp_file
= get_dwp_file ();
10971 if (dwp_file
!= NULL
)
10973 const struct dwp_hash_table
*dwp_htab
=
10974 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10976 if (dwp_htab
!= NULL
)
10978 struct dwo_unit
*dwo_cutu
=
10979 lookup_dwo_unit_in_dwp (dwp_file
, comp_dir
,
10980 signature
, is_debug_types
);
10982 if (dwo_cutu
!= NULL
)
10984 if (dwarf_read_debug
)
10986 fprintf_unfiltered (gdb_stdlog
,
10987 "Virtual DWO %s %s found: @%s\n",
10988 kind
, hex_string (signature
),
10989 host_address_to_string (dwo_cutu
));
10997 /* No DWP file, look for the DWO file. */
10999 dwo_file_slot
= lookup_dwo_file_slot (dwo_name
, comp_dir
);
11000 if (*dwo_file_slot
== NULL
)
11002 /* Read in the file and build a table of the CUs/TUs it contains. */
11003 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
11005 /* NOTE: This will be NULL if unable to open the file. */
11006 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11008 if (dwo_file
!= NULL
)
11010 struct dwo_unit
*dwo_cutu
= NULL
;
11012 if (is_debug_types
&& dwo_file
->tus
)
11014 struct dwo_unit find_dwo_cutu
;
11016 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
11017 find_dwo_cutu
.signature
= signature
;
11019 = (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_cutu
);
11021 else if (!is_debug_types
&& dwo_file
->cu
)
11023 if (signature
== dwo_file
->cu
->signature
)
11024 dwo_cutu
= dwo_file
->cu
;
11027 if (dwo_cutu
!= NULL
)
11029 if (dwarf_read_debug
)
11031 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
11032 kind
, dwo_name
, hex_string (signature
),
11033 host_address_to_string (dwo_cutu
));
11040 /* We didn't find it. This could mean a dwo_id mismatch, or
11041 someone deleted the DWO/DWP file, or the search path isn't set up
11042 correctly to find the file. */
11044 if (dwarf_read_debug
)
11046 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
11047 kind
, dwo_name
, hex_string (signature
));
11050 /* This is a warning and not a complaint because it can be caused by
11051 pilot error (e.g., user accidentally deleting the DWO). */
11053 /* Print the name of the DWP file if we looked there, helps the user
11054 better diagnose the problem. */
11055 char *dwp_text
= NULL
;
11056 struct cleanup
*cleanups
;
11058 if (dwp_file
!= NULL
)
11059 dwp_text
= xstrprintf (" [in DWP file %s]", lbasename (dwp_file
->name
));
11060 cleanups
= make_cleanup (xfree
, dwp_text
);
11062 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
11063 " [in module %s]"),
11064 kind
, dwo_name
, hex_string (signature
),
11065 dwp_text
!= NULL
? dwp_text
: "",
11066 this_unit
->is_debug_types
? "TU" : "CU",
11067 this_unit
->offset
.sect_off
, objfile_name (objfile
));
11069 do_cleanups (cleanups
);
11074 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
11075 See lookup_dwo_cutu_unit for details. */
11077 static struct dwo_unit
*
11078 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
11079 const char *dwo_name
, const char *comp_dir
,
11080 ULONGEST signature
)
11082 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
11085 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
11086 See lookup_dwo_cutu_unit for details. */
11088 static struct dwo_unit
*
11089 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
11090 const char *dwo_name
, const char *comp_dir
)
11092 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
11095 /* Traversal function for queue_and_load_all_dwo_tus. */
11098 queue_and_load_dwo_tu (void **slot
, void *info
)
11100 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
11101 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
11102 ULONGEST signature
= dwo_unit
->signature
;
11103 struct signatured_type
*sig_type
=
11104 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
11106 if (sig_type
!= NULL
)
11108 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
11110 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
11111 a real dependency of PER_CU on SIG_TYPE. That is detected later
11112 while processing PER_CU. */
11113 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
11114 load_full_type_unit (sig_cu
);
11115 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
11121 /* Queue all TUs contained in the DWO of PER_CU to be read in.
11122 The DWO may have the only definition of the type, though it may not be
11123 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
11124 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
11127 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
11129 struct dwo_unit
*dwo_unit
;
11130 struct dwo_file
*dwo_file
;
11132 gdb_assert (!per_cu
->is_debug_types
);
11133 gdb_assert (get_dwp_file () == NULL
);
11134 gdb_assert (per_cu
->cu
!= NULL
);
11136 dwo_unit
= per_cu
->cu
->dwo_unit
;
11137 gdb_assert (dwo_unit
!= NULL
);
11139 dwo_file
= dwo_unit
->dwo_file
;
11140 if (dwo_file
->tus
!= NULL
)
11141 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
11144 /* Free all resources associated with DWO_FILE.
11145 Close the DWO file and munmap the sections.
11146 All memory should be on the objfile obstack. */
11149 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
11152 /* Note: dbfd is NULL for virtual DWO files. */
11153 gdb_bfd_unref (dwo_file
->dbfd
);
11155 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
11158 /* Wrapper for free_dwo_file for use in cleanups. */
11161 free_dwo_file_cleanup (void *arg
)
11163 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
11164 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11166 free_dwo_file (dwo_file
, objfile
);
11169 /* Traversal function for free_dwo_files. */
11172 free_dwo_file_from_slot (void **slot
, void *info
)
11174 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
11175 struct objfile
*objfile
= (struct objfile
*) info
;
11177 free_dwo_file (dwo_file
, objfile
);
11182 /* Free all resources associated with DWO_FILES. */
11185 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
11187 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
11190 /* Read in various DIEs. */
11192 /* qsort helper for inherit_abstract_dies. */
11195 unsigned_int_compar (const void *ap
, const void *bp
)
11197 unsigned int a
= *(unsigned int *) ap
;
11198 unsigned int b
= *(unsigned int *) bp
;
11200 return (a
> b
) - (b
> a
);
11203 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
11204 Inherit only the children of the DW_AT_abstract_origin DIE not being
11205 already referenced by DW_AT_abstract_origin from the children of the
11209 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
11211 struct die_info
*child_die
;
11212 unsigned die_children_count
;
11213 /* CU offsets which were referenced by children of the current DIE. */
11214 sect_offset
*offsets
;
11215 sect_offset
*offsets_end
, *offsetp
;
11216 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
11217 struct die_info
*origin_die
;
11218 /* Iterator of the ORIGIN_DIE children. */
11219 struct die_info
*origin_child_die
;
11220 struct cleanup
*cleanups
;
11221 struct attribute
*attr
;
11222 struct dwarf2_cu
*origin_cu
;
11223 struct pending
**origin_previous_list_in_scope
;
11225 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11229 /* Note that following die references may follow to a die in a
11233 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
11235 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
11237 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
11238 origin_cu
->list_in_scope
= cu
->list_in_scope
;
11240 if (die
->tag
!= origin_die
->tag
11241 && !(die
->tag
== DW_TAG_inlined_subroutine
11242 && origin_die
->tag
== DW_TAG_subprogram
))
11243 complaint (&symfile_complaints
,
11244 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
11245 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
11247 child_die
= die
->child
;
11248 die_children_count
= 0;
11249 while (child_die
&& child_die
->tag
)
11251 child_die
= sibling_die (child_die
);
11252 die_children_count
++;
11254 offsets
= XNEWVEC (sect_offset
, die_children_count
);
11255 cleanups
= make_cleanup (xfree
, offsets
);
11257 offsets_end
= offsets
;
11258 for (child_die
= die
->child
;
11259 child_die
&& child_die
->tag
;
11260 child_die
= sibling_die (child_die
))
11262 struct die_info
*child_origin_die
;
11263 struct dwarf2_cu
*child_origin_cu
;
11265 /* We are trying to process concrete instance entries:
11266 DW_TAG_GNU_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
11267 it's not relevant to our analysis here. i.e. detecting DIEs that are
11268 present in the abstract instance but not referenced in the concrete
11270 if (child_die
->tag
== DW_TAG_GNU_call_site
)
11273 /* For each CHILD_DIE, find the corresponding child of
11274 ORIGIN_DIE. If there is more than one layer of
11275 DW_AT_abstract_origin, follow them all; there shouldn't be,
11276 but GCC versions at least through 4.4 generate this (GCC PR
11278 child_origin_die
= child_die
;
11279 child_origin_cu
= cu
;
11282 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
11286 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
11290 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
11291 counterpart may exist. */
11292 if (child_origin_die
!= child_die
)
11294 if (child_die
->tag
!= child_origin_die
->tag
11295 && !(child_die
->tag
== DW_TAG_inlined_subroutine
11296 && child_origin_die
->tag
== DW_TAG_subprogram
))
11297 complaint (&symfile_complaints
,
11298 _("Child DIE 0x%x and its abstract origin 0x%x have "
11299 "different tags"), child_die
->offset
.sect_off
,
11300 child_origin_die
->offset
.sect_off
);
11301 if (child_origin_die
->parent
!= origin_die
)
11302 complaint (&symfile_complaints
,
11303 _("Child DIE 0x%x and its abstract origin 0x%x have "
11304 "different parents"), child_die
->offset
.sect_off
,
11305 child_origin_die
->offset
.sect_off
);
11307 *offsets_end
++ = child_origin_die
->offset
;
11310 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
11311 unsigned_int_compar
);
11312 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
11313 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
11314 complaint (&symfile_complaints
,
11315 _("Multiple children of DIE 0x%x refer "
11316 "to DIE 0x%x as their abstract origin"),
11317 die
->offset
.sect_off
, offsetp
->sect_off
);
11320 origin_child_die
= origin_die
->child
;
11321 while (origin_child_die
&& origin_child_die
->tag
)
11323 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11324 while (offsetp
< offsets_end
11325 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
11327 if (offsetp
>= offsets_end
11328 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
11330 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11331 Check whether we're already processing ORIGIN_CHILD_DIE.
11332 This can happen with mutually referenced abstract_origins.
11334 if (!origin_child_die
->in_process
)
11335 process_die (origin_child_die
, origin_cu
);
11337 origin_child_die
= sibling_die (origin_child_die
);
11339 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
11341 do_cleanups (cleanups
);
11345 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11347 struct objfile
*objfile
= cu
->objfile
;
11348 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11349 struct context_stack
*newobj
;
11352 struct die_info
*child_die
;
11353 struct attribute
*attr
, *call_line
, *call_file
;
11355 CORE_ADDR baseaddr
;
11356 struct block
*block
;
11357 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11358 VEC (symbolp
) *template_args
= NULL
;
11359 struct template_symbol
*templ_func
= NULL
;
11363 /* If we do not have call site information, we can't show the
11364 caller of this inlined function. That's too confusing, so
11365 only use the scope for local variables. */
11366 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
11367 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
11368 if (call_line
== NULL
|| call_file
== NULL
)
11370 read_lexical_block_scope (die
, cu
);
11375 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11377 name
= dwarf2_name (die
, cu
);
11379 /* Ignore functions with missing or empty names. These are actually
11380 illegal according to the DWARF standard. */
11383 complaint (&symfile_complaints
,
11384 _("missing name for subprogram DIE at %d"),
11385 die
->offset
.sect_off
);
11389 /* Ignore functions with missing or invalid low and high pc attributes. */
11390 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
11391 <= PC_BOUNDS_INVALID
)
11393 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
11394 if (!attr
|| !DW_UNSND (attr
))
11395 complaint (&symfile_complaints
,
11396 _("cannot get low and high bounds "
11397 "for subprogram DIE at %d"),
11398 die
->offset
.sect_off
);
11402 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11403 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11405 /* If we have any template arguments, then we must allocate a
11406 different sort of symbol. */
11407 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
11409 if (child_die
->tag
== DW_TAG_template_type_param
11410 || child_die
->tag
== DW_TAG_template_value_param
)
11412 templ_func
= allocate_template_symbol (objfile
);
11413 templ_func
->base
.is_cplus_template_function
= 1;
11418 newobj
= push_context (0, lowpc
);
11419 newobj
->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
11420 (struct symbol
*) templ_func
);
11422 /* If there is a location expression for DW_AT_frame_base, record
11424 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
11426 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
11428 /* If there is a location for the static link, record it. */
11429 newobj
->static_link
= NULL
;
11430 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
11433 newobj
->static_link
11434 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
11435 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
);
11438 cu
->list_in_scope
= &local_symbols
;
11440 if (die
->child
!= NULL
)
11442 child_die
= die
->child
;
11443 while (child_die
&& child_die
->tag
)
11445 if (child_die
->tag
== DW_TAG_template_type_param
11446 || child_die
->tag
== DW_TAG_template_value_param
)
11448 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
11451 VEC_safe_push (symbolp
, template_args
, arg
);
11454 process_die (child_die
, cu
);
11455 child_die
= sibling_die (child_die
);
11459 inherit_abstract_dies (die
, cu
);
11461 /* If we have a DW_AT_specification, we might need to import using
11462 directives from the context of the specification DIE. See the
11463 comment in determine_prefix. */
11464 if (cu
->language
== language_cplus
11465 && dwarf2_attr (die
, DW_AT_specification
, cu
))
11467 struct dwarf2_cu
*spec_cu
= cu
;
11468 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
11472 child_die
= spec_die
->child
;
11473 while (child_die
&& child_die
->tag
)
11475 if (child_die
->tag
== DW_TAG_imported_module
)
11476 process_die (child_die
, spec_cu
);
11477 child_die
= sibling_die (child_die
);
11480 /* In some cases, GCC generates specification DIEs that
11481 themselves contain DW_AT_specification attributes. */
11482 spec_die
= die_specification (spec_die
, &spec_cu
);
11486 newobj
= pop_context ();
11487 /* Make a block for the local symbols within. */
11488 block
= finish_block (newobj
->name
, &local_symbols
, newobj
->old_blocks
,
11489 newobj
->static_link
, lowpc
, highpc
);
11491 /* For C++, set the block's scope. */
11492 if ((cu
->language
== language_cplus
11493 || cu
->language
== language_fortran
11494 || cu
->language
== language_d
11495 || cu
->language
== language_rust
)
11496 && cu
->processing_has_namespace_info
)
11497 block_set_scope (block
, determine_prefix (die
, cu
),
11498 &objfile
->objfile_obstack
);
11500 /* If we have address ranges, record them. */
11501 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11503 gdbarch_make_symbol_special (gdbarch
, newobj
->name
, objfile
);
11505 /* Attach template arguments to function. */
11506 if (! VEC_empty (symbolp
, template_args
))
11508 gdb_assert (templ_func
!= NULL
);
11510 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
11511 templ_func
->template_arguments
11512 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
11513 templ_func
->n_template_arguments
);
11514 memcpy (templ_func
->template_arguments
,
11515 VEC_address (symbolp
, template_args
),
11516 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
11517 VEC_free (symbolp
, template_args
);
11520 /* In C++, we can have functions nested inside functions (e.g., when
11521 a function declares a class that has methods). This means that
11522 when we finish processing a function scope, we may need to go
11523 back to building a containing block's symbol lists. */
11524 local_symbols
= newobj
->locals
;
11525 local_using_directives
= newobj
->local_using_directives
;
11527 /* If we've finished processing a top-level function, subsequent
11528 symbols go in the file symbol list. */
11529 if (outermost_context_p ())
11530 cu
->list_in_scope
= &file_symbols
;
11533 /* Process all the DIES contained within a lexical block scope. Start
11534 a new scope, process the dies, and then close the scope. */
11537 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11539 struct objfile
*objfile
= cu
->objfile
;
11540 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11541 struct context_stack
*newobj
;
11542 CORE_ADDR lowpc
, highpc
;
11543 struct die_info
*child_die
;
11544 CORE_ADDR baseaddr
;
11546 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11548 /* Ignore blocks with missing or invalid low and high pc attributes. */
11549 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11550 as multiple lexical blocks? Handling children in a sane way would
11551 be nasty. Might be easier to properly extend generic blocks to
11552 describe ranges. */
11553 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11555 case PC_BOUNDS_NOT_PRESENT
:
11556 /* DW_TAG_lexical_block has no attributes, process its children as if
11557 there was no wrapping by that DW_TAG_lexical_block.
11558 GCC does no longer produces such DWARF since GCC r224161. */
11559 for (child_die
= die
->child
;
11560 child_die
!= NULL
&& child_die
->tag
;
11561 child_die
= sibling_die (child_die
))
11562 process_die (child_die
, cu
);
11564 case PC_BOUNDS_INVALID
:
11567 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11568 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11570 push_context (0, lowpc
);
11571 if (die
->child
!= NULL
)
11573 child_die
= die
->child
;
11574 while (child_die
&& child_die
->tag
)
11576 process_die (child_die
, cu
);
11577 child_die
= sibling_die (child_die
);
11580 inherit_abstract_dies (die
, cu
);
11581 newobj
= pop_context ();
11583 if (local_symbols
!= NULL
|| local_using_directives
!= NULL
)
11585 struct block
*block
11586 = finish_block (0, &local_symbols
, newobj
->old_blocks
, NULL
,
11587 newobj
->start_addr
, highpc
);
11589 /* Note that recording ranges after traversing children, as we
11590 do here, means that recording a parent's ranges entails
11591 walking across all its children's ranges as they appear in
11592 the address map, which is quadratic behavior.
11594 It would be nicer to record the parent's ranges before
11595 traversing its children, simply overriding whatever you find
11596 there. But since we don't even decide whether to create a
11597 block until after we've traversed its children, that's hard
11599 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11601 local_symbols
= newobj
->locals
;
11602 local_using_directives
= newobj
->local_using_directives
;
11605 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11608 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11610 struct objfile
*objfile
= cu
->objfile
;
11611 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11612 CORE_ADDR pc
, baseaddr
;
11613 struct attribute
*attr
;
11614 struct call_site
*call_site
, call_site_local
;
11617 struct die_info
*child_die
;
11619 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11621 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11624 complaint (&symfile_complaints
,
11625 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11626 "DIE 0x%x [in module %s]"),
11627 die
->offset
.sect_off
, objfile_name (objfile
));
11630 pc
= attr_value_as_address (attr
) + baseaddr
;
11631 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
11633 if (cu
->call_site_htab
== NULL
)
11634 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
11635 NULL
, &objfile
->objfile_obstack
,
11636 hashtab_obstack_allocate
, NULL
);
11637 call_site_local
.pc
= pc
;
11638 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
11641 complaint (&symfile_complaints
,
11642 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11643 "DIE 0x%x [in module %s]"),
11644 paddress (gdbarch
, pc
), die
->offset
.sect_off
,
11645 objfile_name (objfile
));
11649 /* Count parameters at the caller. */
11652 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11653 child_die
= sibling_die (child_die
))
11655 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11657 complaint (&symfile_complaints
,
11658 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11659 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11660 child_die
->tag
, child_die
->offset
.sect_off
,
11661 objfile_name (objfile
));
11669 = ((struct call_site
*)
11670 obstack_alloc (&objfile
->objfile_obstack
,
11671 sizeof (*call_site
)
11672 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
11674 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
11675 call_site
->pc
= pc
;
11677 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
11679 struct die_info
*func_die
;
11681 /* Skip also over DW_TAG_inlined_subroutine. */
11682 for (func_die
= die
->parent
;
11683 func_die
&& func_die
->tag
!= DW_TAG_subprogram
11684 && func_die
->tag
!= DW_TAG_subroutine_type
;
11685 func_die
= func_die
->parent
);
11687 /* DW_AT_GNU_all_call_sites is a superset
11688 of DW_AT_GNU_all_tail_call_sites. */
11690 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
11691 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
11693 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11694 not complete. But keep CALL_SITE for look ups via call_site_htab,
11695 both the initial caller containing the real return address PC and
11696 the final callee containing the current PC of a chain of tail
11697 calls do not need to have the tail call list complete. But any
11698 function candidate for a virtual tail call frame searched via
11699 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11700 determined unambiguously. */
11704 struct type
*func_type
= NULL
;
11707 func_type
= get_die_type (func_die
, cu
);
11708 if (func_type
!= NULL
)
11710 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
11712 /* Enlist this call site to the function. */
11713 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
11714 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
11717 complaint (&symfile_complaints
,
11718 _("Cannot find function owning DW_TAG_GNU_call_site "
11719 "DIE 0x%x [in module %s]"),
11720 die
->offset
.sect_off
, objfile_name (objfile
));
11724 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
11726 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11727 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
11728 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
11729 /* Keep NULL DWARF_BLOCK. */;
11730 else if (attr_form_is_block (attr
))
11732 struct dwarf2_locexpr_baton
*dlbaton
;
11734 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
11735 dlbaton
->data
= DW_BLOCK (attr
)->data
;
11736 dlbaton
->size
= DW_BLOCK (attr
)->size
;
11737 dlbaton
->per_cu
= cu
->per_cu
;
11739 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
11741 else if (attr_form_is_ref (attr
))
11743 struct dwarf2_cu
*target_cu
= cu
;
11744 struct die_info
*target_die
;
11746 target_die
= follow_die_ref (die
, attr
, &target_cu
);
11747 gdb_assert (target_cu
->objfile
== objfile
);
11748 if (die_is_declaration (target_die
, target_cu
))
11750 const char *target_physname
;
11752 /* Prefer the mangled name; otherwise compute the demangled one. */
11753 target_physname
= dwarf2_string_attr (target_die
,
11754 DW_AT_linkage_name
,
11756 if (target_physname
== NULL
)
11757 target_physname
= dwarf2_string_attr (target_die
,
11758 DW_AT_MIPS_linkage_name
,
11760 if (target_physname
== NULL
)
11761 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
11762 if (target_physname
== NULL
)
11763 complaint (&symfile_complaints
,
11764 _("DW_AT_GNU_call_site_target target DIE has invalid "
11765 "physname, for referencing DIE 0x%x [in module %s]"),
11766 die
->offset
.sect_off
, objfile_name (objfile
));
11768 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
11774 /* DW_AT_entry_pc should be preferred. */
11775 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
11776 <= PC_BOUNDS_INVALID
)
11777 complaint (&symfile_complaints
,
11778 _("DW_AT_GNU_call_site_target target DIE has invalid "
11779 "low pc, for referencing DIE 0x%x [in module %s]"),
11780 die
->offset
.sect_off
, objfile_name (objfile
));
11783 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11784 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
11789 complaint (&symfile_complaints
,
11790 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11791 "block nor reference, for DIE 0x%x [in module %s]"),
11792 die
->offset
.sect_off
, objfile_name (objfile
));
11794 call_site
->per_cu
= cu
->per_cu
;
11796 for (child_die
= die
->child
;
11797 child_die
&& child_die
->tag
;
11798 child_die
= sibling_die (child_die
))
11800 struct call_site_parameter
*parameter
;
11801 struct attribute
*loc
, *origin
;
11803 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11805 /* Already printed the complaint above. */
11809 gdb_assert (call_site
->parameter_count
< nparams
);
11810 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
11812 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11813 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11814 register is contained in DW_AT_GNU_call_site_value. */
11816 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
11817 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
11818 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
11820 sect_offset offset
;
11822 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
11823 offset
= dwarf2_get_ref_die_offset (origin
);
11824 if (!offset_in_cu_p (&cu
->header
, offset
))
11826 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11827 binding can be done only inside one CU. Such referenced DIE
11828 therefore cannot be even moved to DW_TAG_partial_unit. */
11829 complaint (&symfile_complaints
,
11830 _("DW_AT_abstract_origin offset is not in CU for "
11831 "DW_TAG_GNU_call_site child DIE 0x%x "
11833 child_die
->offset
.sect_off
, objfile_name (objfile
));
11836 parameter
->u
.param_offset
.cu_off
= (offset
.sect_off
11837 - cu
->header
.offset
.sect_off
);
11839 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
11841 complaint (&symfile_complaints
,
11842 _("No DW_FORM_block* DW_AT_location for "
11843 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11844 child_die
->offset
.sect_off
, objfile_name (objfile
));
11849 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
11850 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
11851 if (parameter
->u
.dwarf_reg
!= -1)
11852 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
11853 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
11854 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
11855 ¶meter
->u
.fb_offset
))
11856 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
11859 complaint (&symfile_complaints
,
11860 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11861 "for DW_FORM_block* DW_AT_location is supported for "
11862 "DW_TAG_GNU_call_site child DIE 0x%x "
11864 child_die
->offset
.sect_off
, objfile_name (objfile
));
11869 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
11870 if (!attr_form_is_block (attr
))
11872 complaint (&symfile_complaints
,
11873 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11874 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11875 child_die
->offset
.sect_off
, objfile_name (objfile
));
11878 parameter
->value
= DW_BLOCK (attr
)->data
;
11879 parameter
->value_size
= DW_BLOCK (attr
)->size
;
11881 /* Parameters are not pre-cleared by memset above. */
11882 parameter
->data_value
= NULL
;
11883 parameter
->data_value_size
= 0;
11884 call_site
->parameter_count
++;
11886 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
11889 if (!attr_form_is_block (attr
))
11890 complaint (&symfile_complaints
,
11891 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11892 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11893 child_die
->offset
.sect_off
, objfile_name (objfile
));
11896 parameter
->data_value
= DW_BLOCK (attr
)->data
;
11897 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
11903 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11904 Return 1 if the attributes are present and valid, otherwise, return 0.
11905 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11908 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
11909 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
11910 struct partial_symtab
*ranges_pst
)
11912 struct objfile
*objfile
= cu
->objfile
;
11913 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11914 struct comp_unit_head
*cu_header
= &cu
->header
;
11915 bfd
*obfd
= objfile
->obfd
;
11916 unsigned int addr_size
= cu_header
->addr_size
;
11917 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
11918 /* Base address selection entry. */
11921 unsigned int dummy
;
11922 const gdb_byte
*buffer
;
11925 CORE_ADDR high
= 0;
11926 CORE_ADDR baseaddr
;
11928 found_base
= cu
->base_known
;
11929 base
= cu
->base_address
;
11931 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
11932 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
11934 complaint (&symfile_complaints
,
11935 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11939 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
11943 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11947 CORE_ADDR range_beginning
, range_end
;
11949 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
11950 buffer
+= addr_size
;
11951 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
11952 buffer
+= addr_size
;
11953 offset
+= 2 * addr_size
;
11955 /* An end of list marker is a pair of zero addresses. */
11956 if (range_beginning
== 0 && range_end
== 0)
11957 /* Found the end of list entry. */
11960 /* Each base address selection entry is a pair of 2 values.
11961 The first is the largest possible address, the second is
11962 the base address. Check for a base address here. */
11963 if ((range_beginning
& mask
) == mask
)
11965 /* If we found the largest possible address, then we already
11966 have the base address in range_end. */
11974 /* We have no valid base address for the ranges
11976 complaint (&symfile_complaints
,
11977 _("Invalid .debug_ranges data (no base address)"));
11981 if (range_beginning
> range_end
)
11983 /* Inverted range entries are invalid. */
11984 complaint (&symfile_complaints
,
11985 _("Invalid .debug_ranges data (inverted range)"));
11989 /* Empty range entries have no effect. */
11990 if (range_beginning
== range_end
)
11993 range_beginning
+= base
;
11996 /* A not-uncommon case of bad debug info.
11997 Don't pollute the addrmap with bad data. */
11998 if (range_beginning
+ baseaddr
== 0
11999 && !dwarf2_per_objfile
->has_section_at_zero
)
12001 complaint (&symfile_complaints
,
12002 _(".debug_ranges entry has start address of zero"
12003 " [in module %s]"), objfile_name (objfile
));
12007 if (ranges_pst
!= NULL
)
12012 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
12013 range_beginning
+ baseaddr
);
12014 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
12015 range_end
+ baseaddr
);
12016 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
12020 /* FIXME: This is recording everything as a low-high
12021 segment of consecutive addresses. We should have a
12022 data structure for discontiguous block ranges
12026 low
= range_beginning
;
12032 if (range_beginning
< low
)
12033 low
= range_beginning
;
12034 if (range_end
> high
)
12040 /* If the first entry is an end-of-list marker, the range
12041 describes an empty scope, i.e. no instructions. */
12047 *high_return
= high
;
12051 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
12052 definition for the return value. *LOWPC and *HIGHPC are set iff
12053 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
12055 static enum pc_bounds_kind
12056 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
12057 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
12058 struct partial_symtab
*pst
)
12060 struct attribute
*attr
;
12061 struct attribute
*attr_high
;
12063 CORE_ADDR high
= 0;
12064 enum pc_bounds_kind ret
;
12066 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12069 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12072 low
= attr_value_as_address (attr
);
12073 high
= attr_value_as_address (attr_high
);
12074 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12078 /* Found high w/o low attribute. */
12079 return PC_BOUNDS_INVALID
;
12081 /* Found consecutive range of addresses. */
12082 ret
= PC_BOUNDS_HIGH_LOW
;
12086 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12089 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12090 We take advantage of the fact that DW_AT_ranges does not appear
12091 in DW_TAG_compile_unit of DWO files. */
12092 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12093 unsigned int ranges_offset
= (DW_UNSND (attr
)
12094 + (need_ranges_base
12098 /* Value of the DW_AT_ranges attribute is the offset in the
12099 .debug_ranges section. */
12100 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
12101 return PC_BOUNDS_INVALID
;
12102 /* Found discontinuous range of addresses. */
12103 ret
= PC_BOUNDS_RANGES
;
12106 return PC_BOUNDS_NOT_PRESENT
;
12109 /* read_partial_die has also the strict LOW < HIGH requirement. */
12111 return PC_BOUNDS_INVALID
;
12113 /* When using the GNU linker, .gnu.linkonce. sections are used to
12114 eliminate duplicate copies of functions and vtables and such.
12115 The linker will arbitrarily choose one and discard the others.
12116 The AT_*_pc values for such functions refer to local labels in
12117 these sections. If the section from that file was discarded, the
12118 labels are not in the output, so the relocs get a value of 0.
12119 If this is a discarded function, mark the pc bounds as invalid,
12120 so that GDB will ignore it. */
12121 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12122 return PC_BOUNDS_INVALID
;
12130 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
12131 its low and high PC addresses. Do nothing if these addresses could not
12132 be determined. Otherwise, set LOWPC to the low address if it is smaller,
12133 and HIGHPC to the high address if greater than HIGHPC. */
12136 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
12137 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12138 struct dwarf2_cu
*cu
)
12140 CORE_ADDR low
, high
;
12141 struct die_info
*child
= die
->child
;
12143 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
12145 *lowpc
= std::min (*lowpc
, low
);
12146 *highpc
= std::max (*highpc
, high
);
12149 /* If the language does not allow nested subprograms (either inside
12150 subprograms or lexical blocks), we're done. */
12151 if (cu
->language
!= language_ada
)
12154 /* Check all the children of the given DIE. If it contains nested
12155 subprograms, then check their pc bounds. Likewise, we need to
12156 check lexical blocks as well, as they may also contain subprogram
12158 while (child
&& child
->tag
)
12160 if (child
->tag
== DW_TAG_subprogram
12161 || child
->tag
== DW_TAG_lexical_block
)
12162 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
12163 child
= sibling_die (child
);
12167 /* Get the low and high pc's represented by the scope DIE, and store
12168 them in *LOWPC and *HIGHPC. If the correct values can't be
12169 determined, set *LOWPC to -1 and *HIGHPC to 0. */
12172 get_scope_pc_bounds (struct die_info
*die
,
12173 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12174 struct dwarf2_cu
*cu
)
12176 CORE_ADDR best_low
= (CORE_ADDR
) -1;
12177 CORE_ADDR best_high
= (CORE_ADDR
) 0;
12178 CORE_ADDR current_low
, current_high
;
12180 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
12181 >= PC_BOUNDS_RANGES
)
12183 best_low
= current_low
;
12184 best_high
= current_high
;
12188 struct die_info
*child
= die
->child
;
12190 while (child
&& child
->tag
)
12192 switch (child
->tag
) {
12193 case DW_TAG_subprogram
:
12194 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
12196 case DW_TAG_namespace
:
12197 case DW_TAG_module
:
12198 /* FIXME: carlton/2004-01-16: Should we do this for
12199 DW_TAG_class_type/DW_TAG_structure_type, too? I think
12200 that current GCC's always emit the DIEs corresponding
12201 to definitions of methods of classes as children of a
12202 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
12203 the DIEs giving the declarations, which could be
12204 anywhere). But I don't see any reason why the
12205 standards says that they have to be there. */
12206 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
12208 if (current_low
!= ((CORE_ADDR
) -1))
12210 best_low
= std::min (best_low
, current_low
);
12211 best_high
= std::max (best_high
, current_high
);
12219 child
= sibling_die (child
);
12224 *highpc
= best_high
;
12227 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
12231 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
12232 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
12234 struct objfile
*objfile
= cu
->objfile
;
12235 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12236 struct attribute
*attr
;
12237 struct attribute
*attr_high
;
12239 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12242 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12245 CORE_ADDR low
= attr_value_as_address (attr
);
12246 CORE_ADDR high
= attr_value_as_address (attr_high
);
12248 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12251 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
12252 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
12253 record_block_range (block
, low
, high
- 1);
12257 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12260 bfd
*obfd
= objfile
->obfd
;
12261 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12262 We take advantage of the fact that DW_AT_ranges does not appear
12263 in DW_TAG_compile_unit of DWO files. */
12264 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12266 /* The value of the DW_AT_ranges attribute is the offset of the
12267 address range list in the .debug_ranges section. */
12268 unsigned long offset
= (DW_UNSND (attr
)
12269 + (need_ranges_base
? cu
->ranges_base
: 0));
12270 const gdb_byte
*buffer
;
12272 /* For some target architectures, but not others, the
12273 read_address function sign-extends the addresses it returns.
12274 To recognize base address selection entries, we need a
12276 unsigned int addr_size
= cu
->header
.addr_size
;
12277 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
12279 /* The base address, to which the next pair is relative. Note
12280 that this 'base' is a DWARF concept: most entries in a range
12281 list are relative, to reduce the number of relocs against the
12282 debugging information. This is separate from this function's
12283 'baseaddr' argument, which GDB uses to relocate debugging
12284 information from a shared library based on the address at
12285 which the library was loaded. */
12286 CORE_ADDR base
= cu
->base_address
;
12287 int base_known
= cu
->base_known
;
12289 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
12290 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
12292 complaint (&symfile_complaints
,
12293 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
12297 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
12301 unsigned int bytes_read
;
12302 CORE_ADDR start
, end
;
12304 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12305 buffer
+= bytes_read
;
12306 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12307 buffer
+= bytes_read
;
12309 /* Did we find the end of the range list? */
12310 if (start
== 0 && end
== 0)
12313 /* Did we find a base address selection entry? */
12314 else if ((start
& base_select_mask
) == base_select_mask
)
12320 /* We found an ordinary address range. */
12325 complaint (&symfile_complaints
,
12326 _("Invalid .debug_ranges data "
12327 "(no base address)"));
12333 /* Inverted range entries are invalid. */
12334 complaint (&symfile_complaints
,
12335 _("Invalid .debug_ranges data "
12336 "(inverted range)"));
12340 /* Empty range entries have no effect. */
12344 start
+= base
+ baseaddr
;
12345 end
+= base
+ baseaddr
;
12347 /* A not-uncommon case of bad debug info.
12348 Don't pollute the addrmap with bad data. */
12349 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12351 complaint (&symfile_complaints
,
12352 _(".debug_ranges entry has start address of zero"
12353 " [in module %s]"), objfile_name (objfile
));
12357 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
12358 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
12359 record_block_range (block
, start
, end
- 1);
12365 /* Check whether the producer field indicates either of GCC < 4.6, or the
12366 Intel C/C++ compiler, and cache the result in CU. */
12369 check_producer (struct dwarf2_cu
*cu
)
12373 if (cu
->producer
== NULL
)
12375 /* For unknown compilers expect their behavior is DWARF version
12378 GCC started to support .debug_types sections by -gdwarf-4 since
12379 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12380 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12381 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12382 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12384 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
12386 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
12387 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
12389 else if (startswith (cu
->producer
, "Intel(R) C"))
12390 cu
->producer_is_icc
= 1;
12393 /* For other non-GCC compilers, expect their behavior is DWARF version
12397 cu
->checked_producer
= 1;
12400 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12401 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12402 during 4.6.0 experimental. */
12405 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
12407 if (!cu
->checked_producer
)
12408 check_producer (cu
);
12410 return cu
->producer_is_gxx_lt_4_6
;
12413 /* Return the default accessibility type if it is not overriden by
12414 DW_AT_accessibility. */
12416 static enum dwarf_access_attribute
12417 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
12419 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
12421 /* The default DWARF 2 accessibility for members is public, the default
12422 accessibility for inheritance is private. */
12424 if (die
->tag
!= DW_TAG_inheritance
)
12425 return DW_ACCESS_public
;
12427 return DW_ACCESS_private
;
12431 /* DWARF 3+ defines the default accessibility a different way. The same
12432 rules apply now for DW_TAG_inheritance as for the members and it only
12433 depends on the container kind. */
12435 if (die
->parent
->tag
== DW_TAG_class_type
)
12436 return DW_ACCESS_private
;
12438 return DW_ACCESS_public
;
12442 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12443 offset. If the attribute was not found return 0, otherwise return
12444 1. If it was found but could not properly be handled, set *OFFSET
12448 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
12451 struct attribute
*attr
;
12453 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
12458 /* Note that we do not check for a section offset first here.
12459 This is because DW_AT_data_member_location is new in DWARF 4,
12460 so if we see it, we can assume that a constant form is really
12461 a constant and not a section offset. */
12462 if (attr_form_is_constant (attr
))
12463 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
12464 else if (attr_form_is_section_offset (attr
))
12465 dwarf2_complex_location_expr_complaint ();
12466 else if (attr_form_is_block (attr
))
12467 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12469 dwarf2_complex_location_expr_complaint ();
12477 /* Add an aggregate field to the field list. */
12480 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
12481 struct dwarf2_cu
*cu
)
12483 struct objfile
*objfile
= cu
->objfile
;
12484 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12485 struct nextfield
*new_field
;
12486 struct attribute
*attr
;
12488 const char *fieldname
= "";
12490 /* Allocate a new field list entry and link it in. */
12491 new_field
= XNEW (struct nextfield
);
12492 make_cleanup (xfree
, new_field
);
12493 memset (new_field
, 0, sizeof (struct nextfield
));
12495 if (die
->tag
== DW_TAG_inheritance
)
12497 new_field
->next
= fip
->baseclasses
;
12498 fip
->baseclasses
= new_field
;
12502 new_field
->next
= fip
->fields
;
12503 fip
->fields
= new_field
;
12507 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12509 new_field
->accessibility
= DW_UNSND (attr
);
12511 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
12512 if (new_field
->accessibility
!= DW_ACCESS_public
)
12513 fip
->non_public_fields
= 1;
12515 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12517 new_field
->virtuality
= DW_UNSND (attr
);
12519 new_field
->virtuality
= DW_VIRTUALITY_none
;
12521 fp
= &new_field
->field
;
12523 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
12527 /* Data member other than a C++ static data member. */
12529 /* Get type of field. */
12530 fp
->type
= die_type (die
, cu
);
12532 SET_FIELD_BITPOS (*fp
, 0);
12534 /* Get bit size of field (zero if none). */
12535 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
12538 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
12542 FIELD_BITSIZE (*fp
) = 0;
12545 /* Get bit offset of field. */
12546 if (handle_data_member_location (die
, cu
, &offset
))
12547 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12548 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
12551 if (gdbarch_bits_big_endian (gdbarch
))
12553 /* For big endian bits, the DW_AT_bit_offset gives the
12554 additional bit offset from the MSB of the containing
12555 anonymous object to the MSB of the field. We don't
12556 have to do anything special since we don't need to
12557 know the size of the anonymous object. */
12558 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
12562 /* For little endian bits, compute the bit offset to the
12563 MSB of the anonymous object, subtract off the number of
12564 bits from the MSB of the field to the MSB of the
12565 object, and then subtract off the number of bits of
12566 the field itself. The result is the bit offset of
12567 the LSB of the field. */
12568 int anonymous_size
;
12569 int bit_offset
= DW_UNSND (attr
);
12571 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12574 /* The size of the anonymous object containing
12575 the bit field is explicit, so use the
12576 indicated size (in bytes). */
12577 anonymous_size
= DW_UNSND (attr
);
12581 /* The size of the anonymous object containing
12582 the bit field must be inferred from the type
12583 attribute of the data member containing the
12585 anonymous_size
= TYPE_LENGTH (fp
->type
);
12587 SET_FIELD_BITPOS (*fp
,
12588 (FIELD_BITPOS (*fp
)
12589 + anonymous_size
* bits_per_byte
12590 - bit_offset
- FIELD_BITSIZE (*fp
)));
12593 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
12595 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
12596 + dwarf2_get_attr_constant_value (attr
, 0)));
12598 /* Get name of field. */
12599 fieldname
= dwarf2_name (die
, cu
);
12600 if (fieldname
== NULL
)
12603 /* The name is already allocated along with this objfile, so we don't
12604 need to duplicate it for the type. */
12605 fp
->name
= fieldname
;
12607 /* Change accessibility for artificial fields (e.g. virtual table
12608 pointer or virtual base class pointer) to private. */
12609 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
12611 FIELD_ARTIFICIAL (*fp
) = 1;
12612 new_field
->accessibility
= DW_ACCESS_private
;
12613 fip
->non_public_fields
= 1;
12616 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
12618 /* C++ static member. */
12620 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12621 is a declaration, but all versions of G++ as of this writing
12622 (so through at least 3.2.1) incorrectly generate
12623 DW_TAG_variable tags. */
12625 const char *physname
;
12627 /* Get name of field. */
12628 fieldname
= dwarf2_name (die
, cu
);
12629 if (fieldname
== NULL
)
12632 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
12634 /* Only create a symbol if this is an external value.
12635 new_symbol checks this and puts the value in the global symbol
12636 table, which we want. If it is not external, new_symbol
12637 will try to put the value in cu->list_in_scope which is wrong. */
12638 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
12640 /* A static const member, not much different than an enum as far as
12641 we're concerned, except that we can support more types. */
12642 new_symbol (die
, NULL
, cu
);
12645 /* Get physical name. */
12646 physname
= dwarf2_physname (fieldname
, die
, cu
);
12648 /* The name is already allocated along with this objfile, so we don't
12649 need to duplicate it for the type. */
12650 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
12651 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12652 FIELD_NAME (*fp
) = fieldname
;
12654 else if (die
->tag
== DW_TAG_inheritance
)
12658 /* C++ base class field. */
12659 if (handle_data_member_location (die
, cu
, &offset
))
12660 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12661 FIELD_BITSIZE (*fp
) = 0;
12662 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12663 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
12664 fip
->nbaseclasses
++;
12668 /* Add a typedef defined in the scope of the FIP's class. */
12671 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
12672 struct dwarf2_cu
*cu
)
12674 struct typedef_field_list
*new_field
;
12675 struct typedef_field
*fp
;
12677 /* Allocate a new field list entry and link it in. */
12678 new_field
= XCNEW (struct typedef_field_list
);
12679 make_cleanup (xfree
, new_field
);
12681 gdb_assert (die
->tag
== DW_TAG_typedef
);
12683 fp
= &new_field
->field
;
12685 /* Get name of field. */
12686 fp
->name
= dwarf2_name (die
, cu
);
12687 if (fp
->name
== NULL
)
12690 fp
->type
= read_type_die (die
, cu
);
12692 new_field
->next
= fip
->typedef_field_list
;
12693 fip
->typedef_field_list
= new_field
;
12694 fip
->typedef_field_list_count
++;
12697 /* Create the vector of fields, and attach it to the type. */
12700 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
12701 struct dwarf2_cu
*cu
)
12703 int nfields
= fip
->nfields
;
12705 /* Record the field count, allocate space for the array of fields,
12706 and create blank accessibility bitfields if necessary. */
12707 TYPE_NFIELDS (type
) = nfields
;
12708 TYPE_FIELDS (type
) = (struct field
*)
12709 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
12710 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
12712 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
12714 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12716 TYPE_FIELD_PRIVATE_BITS (type
) =
12717 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12718 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
12720 TYPE_FIELD_PROTECTED_BITS (type
) =
12721 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12722 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
12724 TYPE_FIELD_IGNORE_BITS (type
) =
12725 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12726 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
12729 /* If the type has baseclasses, allocate and clear a bit vector for
12730 TYPE_FIELD_VIRTUAL_BITS. */
12731 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
12733 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
12734 unsigned char *pointer
;
12736 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12737 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
12738 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
12739 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
12740 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
12743 /* Copy the saved-up fields into the field vector. Start from the head of
12744 the list, adding to the tail of the field array, so that they end up in
12745 the same order in the array in which they were added to the list. */
12746 while (nfields
-- > 0)
12748 struct nextfield
*fieldp
;
12752 fieldp
= fip
->fields
;
12753 fip
->fields
= fieldp
->next
;
12757 fieldp
= fip
->baseclasses
;
12758 fip
->baseclasses
= fieldp
->next
;
12761 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
12762 switch (fieldp
->accessibility
)
12764 case DW_ACCESS_private
:
12765 if (cu
->language
!= language_ada
)
12766 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
12769 case DW_ACCESS_protected
:
12770 if (cu
->language
!= language_ada
)
12771 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
12774 case DW_ACCESS_public
:
12778 /* Unknown accessibility. Complain and treat it as public. */
12780 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
12781 fieldp
->accessibility
);
12785 if (nfields
< fip
->nbaseclasses
)
12787 switch (fieldp
->virtuality
)
12789 case DW_VIRTUALITY_virtual
:
12790 case DW_VIRTUALITY_pure_virtual
:
12791 if (cu
->language
== language_ada
)
12792 error (_("unexpected virtuality in component of Ada type"));
12793 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
12800 /* Return true if this member function is a constructor, false
12804 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
12806 const char *fieldname
;
12807 const char *type_name
;
12810 if (die
->parent
== NULL
)
12813 if (die
->parent
->tag
!= DW_TAG_structure_type
12814 && die
->parent
->tag
!= DW_TAG_union_type
12815 && die
->parent
->tag
!= DW_TAG_class_type
)
12818 fieldname
= dwarf2_name (die
, cu
);
12819 type_name
= dwarf2_name (die
->parent
, cu
);
12820 if (fieldname
== NULL
|| type_name
== NULL
)
12823 len
= strlen (fieldname
);
12824 return (strncmp (fieldname
, type_name
, len
) == 0
12825 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
12828 /* Add a member function to the proper fieldlist. */
12831 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
12832 struct type
*type
, struct dwarf2_cu
*cu
)
12834 struct objfile
*objfile
= cu
->objfile
;
12835 struct attribute
*attr
;
12836 struct fnfieldlist
*flp
;
12838 struct fn_field
*fnp
;
12839 const char *fieldname
;
12840 struct nextfnfield
*new_fnfield
;
12841 struct type
*this_type
;
12842 enum dwarf_access_attribute accessibility
;
12844 if (cu
->language
== language_ada
)
12845 error (_("unexpected member function in Ada type"));
12847 /* Get name of member function. */
12848 fieldname
= dwarf2_name (die
, cu
);
12849 if (fieldname
== NULL
)
12852 /* Look up member function name in fieldlist. */
12853 for (i
= 0; i
< fip
->nfnfields
; i
++)
12855 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
12859 /* Create new list element if necessary. */
12860 if (i
< fip
->nfnfields
)
12861 flp
= &fip
->fnfieldlists
[i
];
12864 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
12866 fip
->fnfieldlists
= (struct fnfieldlist
*)
12867 xrealloc (fip
->fnfieldlists
,
12868 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
12869 * sizeof (struct fnfieldlist
));
12870 if (fip
->nfnfields
== 0)
12871 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
12873 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
12874 flp
->name
= fieldname
;
12877 i
= fip
->nfnfields
++;
12880 /* Create a new member function field and chain it to the field list
12882 new_fnfield
= XNEW (struct nextfnfield
);
12883 make_cleanup (xfree
, new_fnfield
);
12884 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
12885 new_fnfield
->next
= flp
->head
;
12886 flp
->head
= new_fnfield
;
12889 /* Fill in the member function field info. */
12890 fnp
= &new_fnfield
->fnfield
;
12892 /* Delay processing of the physname until later. */
12893 if (cu
->language
== language_cplus
)
12895 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
12900 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
12901 fnp
->physname
= physname
? physname
: "";
12904 fnp
->type
= alloc_type (objfile
);
12905 this_type
= read_type_die (die
, cu
);
12906 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
12908 int nparams
= TYPE_NFIELDS (this_type
);
12910 /* TYPE is the domain of this method, and THIS_TYPE is the type
12911 of the method itself (TYPE_CODE_METHOD). */
12912 smash_to_method_type (fnp
->type
, type
,
12913 TYPE_TARGET_TYPE (this_type
),
12914 TYPE_FIELDS (this_type
),
12915 TYPE_NFIELDS (this_type
),
12916 TYPE_VARARGS (this_type
));
12918 /* Handle static member functions.
12919 Dwarf2 has no clean way to discern C++ static and non-static
12920 member functions. G++ helps GDB by marking the first
12921 parameter for non-static member functions (which is the this
12922 pointer) as artificial. We obtain this information from
12923 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12924 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
12925 fnp
->voffset
= VOFFSET_STATIC
;
12928 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
12929 dwarf2_full_name (fieldname
, die
, cu
));
12931 /* Get fcontext from DW_AT_containing_type if present. */
12932 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
12933 fnp
->fcontext
= die_containing_type (die
, cu
);
12935 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12936 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12938 /* Get accessibility. */
12939 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12941 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
12943 accessibility
= dwarf2_default_access_attribute (die
, cu
);
12944 switch (accessibility
)
12946 case DW_ACCESS_private
:
12947 fnp
->is_private
= 1;
12949 case DW_ACCESS_protected
:
12950 fnp
->is_protected
= 1;
12954 /* Check for artificial methods. */
12955 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
12956 if (attr
&& DW_UNSND (attr
) != 0)
12957 fnp
->is_artificial
= 1;
12959 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
12961 /* Get index in virtual function table if it is a virtual member
12962 function. For older versions of GCC, this is an offset in the
12963 appropriate virtual table, as specified by DW_AT_containing_type.
12964 For everyone else, it is an expression to be evaluated relative
12965 to the object address. */
12967 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
12970 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
12972 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
12974 /* Old-style GCC. */
12975 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
12977 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12978 || (DW_BLOCK (attr
)->size
> 1
12979 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
12980 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
12982 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12983 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
12984 dwarf2_complex_location_expr_complaint ();
12986 fnp
->voffset
/= cu
->header
.addr_size
;
12990 dwarf2_complex_location_expr_complaint ();
12992 if (!fnp
->fcontext
)
12994 /* If there is no `this' field and no DW_AT_containing_type,
12995 we cannot actually find a base class context for the
12997 if (TYPE_NFIELDS (this_type
) == 0
12998 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
13000 complaint (&symfile_complaints
,
13001 _("cannot determine context for virtual member "
13002 "function \"%s\" (offset %d)"),
13003 fieldname
, die
->offset
.sect_off
);
13008 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
13012 else if (attr_form_is_section_offset (attr
))
13014 dwarf2_complex_location_expr_complaint ();
13018 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
13024 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
13025 if (attr
&& DW_UNSND (attr
))
13027 /* GCC does this, as of 2008-08-25; PR debug/37237. */
13028 complaint (&symfile_complaints
,
13029 _("Member function \"%s\" (offset %d) is virtual "
13030 "but the vtable offset is not specified"),
13031 fieldname
, die
->offset
.sect_off
);
13032 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13033 TYPE_CPLUS_DYNAMIC (type
) = 1;
13038 /* Create the vector of member function fields, and attach it to the type. */
13041 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
13042 struct dwarf2_cu
*cu
)
13044 struct fnfieldlist
*flp
;
13047 if (cu
->language
== language_ada
)
13048 error (_("unexpected member functions in Ada type"));
13050 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13051 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
13052 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
13054 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
13056 struct nextfnfield
*nfp
= flp
->head
;
13057 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
13060 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
13061 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
13062 fn_flp
->fn_fields
= (struct fn_field
*)
13063 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
13064 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
13065 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
13068 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
13071 /* Returns non-zero if NAME is the name of a vtable member in CU's
13072 language, zero otherwise. */
13074 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
13076 static const char vptr
[] = "_vptr";
13077 static const char vtable
[] = "vtable";
13079 /* Look for the C++ form of the vtable. */
13080 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
13086 /* GCC outputs unnamed structures that are really pointers to member
13087 functions, with the ABI-specified layout. If TYPE describes
13088 such a structure, smash it into a member function type.
13090 GCC shouldn't do this; it should just output pointer to member DIEs.
13091 This is GCC PR debug/28767. */
13094 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
13096 struct type
*pfn_type
, *self_type
, *new_type
;
13098 /* Check for a structure with no name and two children. */
13099 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
13102 /* Check for __pfn and __delta members. */
13103 if (TYPE_FIELD_NAME (type
, 0) == NULL
13104 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
13105 || TYPE_FIELD_NAME (type
, 1) == NULL
13106 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
13109 /* Find the type of the method. */
13110 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
13111 if (pfn_type
== NULL
13112 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
13113 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
13116 /* Look for the "this" argument. */
13117 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
13118 if (TYPE_NFIELDS (pfn_type
) == 0
13119 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
13120 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
13123 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
13124 new_type
= alloc_type (objfile
);
13125 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
13126 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
13127 TYPE_VARARGS (pfn_type
));
13128 smash_to_methodptr_type (type
, new_type
);
13131 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
13135 producer_is_icc (struct dwarf2_cu
*cu
)
13137 if (!cu
->checked_producer
)
13138 check_producer (cu
);
13140 return cu
->producer_is_icc
;
13143 /* Called when we find the DIE that starts a structure or union scope
13144 (definition) to create a type for the structure or union. Fill in
13145 the type's name and general properties; the members will not be
13146 processed until process_structure_scope. A symbol table entry for
13147 the type will also not be done until process_structure_scope (assuming
13148 the type has a name).
13150 NOTE: we need to call these functions regardless of whether or not the
13151 DIE has a DW_AT_name attribute, since it might be an anonymous
13152 structure or union. This gets the type entered into our set of
13153 user defined types. */
13155 static struct type
*
13156 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13158 struct objfile
*objfile
= cu
->objfile
;
13160 struct attribute
*attr
;
13163 /* If the definition of this type lives in .debug_types, read that type.
13164 Don't follow DW_AT_specification though, that will take us back up
13165 the chain and we want to go down. */
13166 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13169 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13171 /* The type's CU may not be the same as CU.
13172 Ensure TYPE is recorded with CU in die_type_hash. */
13173 return set_die_type (die
, type
, cu
);
13176 type
= alloc_type (objfile
);
13177 INIT_CPLUS_SPECIFIC (type
);
13179 name
= dwarf2_name (die
, cu
);
13182 if (cu
->language
== language_cplus
13183 || cu
->language
== language_d
13184 || cu
->language
== language_rust
)
13186 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
13188 /* dwarf2_full_name might have already finished building the DIE's
13189 type. If so, there is no need to continue. */
13190 if (get_die_type (die
, cu
) != NULL
)
13191 return get_die_type (die
, cu
);
13193 TYPE_TAG_NAME (type
) = full_name
;
13194 if (die
->tag
== DW_TAG_structure_type
13195 || die
->tag
== DW_TAG_class_type
)
13196 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13200 /* The name is already allocated along with this objfile, so
13201 we don't need to duplicate it for the type. */
13202 TYPE_TAG_NAME (type
) = name
;
13203 if (die
->tag
== DW_TAG_class_type
)
13204 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13208 if (die
->tag
== DW_TAG_structure_type
)
13210 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13212 else if (die
->tag
== DW_TAG_union_type
)
13214 TYPE_CODE (type
) = TYPE_CODE_UNION
;
13218 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13221 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
13222 TYPE_DECLARED_CLASS (type
) = 1;
13224 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13227 if (attr_form_is_constant (attr
))
13228 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13231 /* For the moment, dynamic type sizes are not supported
13232 by GDB's struct type. The actual size is determined
13233 on-demand when resolving the type of a given object,
13234 so set the type's length to zero for now. Otherwise,
13235 we record an expression as the length, and that expression
13236 could lead to a very large value, which could eventually
13237 lead to us trying to allocate that much memory when creating
13238 a value of that type. */
13239 TYPE_LENGTH (type
) = 0;
13244 TYPE_LENGTH (type
) = 0;
13247 if (producer_is_icc (cu
) && (TYPE_LENGTH (type
) == 0))
13249 /* ICC does not output the required DW_AT_declaration
13250 on incomplete types, but gives them a size of zero. */
13251 TYPE_STUB (type
) = 1;
13254 TYPE_STUB_SUPPORTED (type
) = 1;
13256 if (die_is_declaration (die
, cu
))
13257 TYPE_STUB (type
) = 1;
13258 else if (attr
== NULL
&& die
->child
== NULL
13259 && producer_is_realview (cu
->producer
))
13260 /* RealView does not output the required DW_AT_declaration
13261 on incomplete types. */
13262 TYPE_STUB (type
) = 1;
13264 /* We need to add the type field to the die immediately so we don't
13265 infinitely recurse when dealing with pointers to the structure
13266 type within the structure itself. */
13267 set_die_type (die
, type
, cu
);
13269 /* set_die_type should be already done. */
13270 set_descriptive_type (type
, die
, cu
);
13275 /* Finish creating a structure or union type, including filling in
13276 its members and creating a symbol for it. */
13279 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13281 struct objfile
*objfile
= cu
->objfile
;
13282 struct die_info
*child_die
;
13285 type
= get_die_type (die
, cu
);
13287 type
= read_structure_type (die
, cu
);
13289 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
13291 struct field_info fi
;
13292 VEC (symbolp
) *template_args
= NULL
;
13293 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
13295 memset (&fi
, 0, sizeof (struct field_info
));
13297 child_die
= die
->child
;
13299 while (child_die
&& child_die
->tag
)
13301 if (child_die
->tag
== DW_TAG_member
13302 || child_die
->tag
== DW_TAG_variable
)
13304 /* NOTE: carlton/2002-11-05: A C++ static data member
13305 should be a DW_TAG_member that is a declaration, but
13306 all versions of G++ as of this writing (so through at
13307 least 3.2.1) incorrectly generate DW_TAG_variable
13308 tags for them instead. */
13309 dwarf2_add_field (&fi
, child_die
, cu
);
13311 else if (child_die
->tag
== DW_TAG_subprogram
)
13313 /* Rust doesn't have member functions in the C++ sense.
13314 However, it does emit ordinary functions as children
13315 of a struct DIE. */
13316 if (cu
->language
== language_rust
)
13317 read_func_scope (child_die
, cu
);
13320 /* C++ member function. */
13321 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
13324 else if (child_die
->tag
== DW_TAG_inheritance
)
13326 /* C++ base class field. */
13327 dwarf2_add_field (&fi
, child_die
, cu
);
13329 else if (child_die
->tag
== DW_TAG_typedef
)
13330 dwarf2_add_typedef (&fi
, child_die
, cu
);
13331 else if (child_die
->tag
== DW_TAG_template_type_param
13332 || child_die
->tag
== DW_TAG_template_value_param
)
13334 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13337 VEC_safe_push (symbolp
, template_args
, arg
);
13340 child_die
= sibling_die (child_die
);
13343 /* Attach template arguments to type. */
13344 if (! VEC_empty (symbolp
, template_args
))
13346 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13347 TYPE_N_TEMPLATE_ARGUMENTS (type
)
13348 = VEC_length (symbolp
, template_args
);
13349 TYPE_TEMPLATE_ARGUMENTS (type
)
13350 = XOBNEWVEC (&objfile
->objfile_obstack
,
13352 TYPE_N_TEMPLATE_ARGUMENTS (type
));
13353 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
13354 VEC_address (symbolp
, template_args
),
13355 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
13356 * sizeof (struct symbol
*)));
13357 VEC_free (symbolp
, template_args
);
13360 /* Attach fields and member functions to the type. */
13362 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
13365 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
13367 /* Get the type which refers to the base class (possibly this
13368 class itself) which contains the vtable pointer for the current
13369 class from the DW_AT_containing_type attribute. This use of
13370 DW_AT_containing_type is a GNU extension. */
13372 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
13374 struct type
*t
= die_containing_type (die
, cu
);
13376 set_type_vptr_basetype (type
, t
);
13381 /* Our own class provides vtbl ptr. */
13382 for (i
= TYPE_NFIELDS (t
) - 1;
13383 i
>= TYPE_N_BASECLASSES (t
);
13386 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
13388 if (is_vtable_name (fieldname
, cu
))
13390 set_type_vptr_fieldno (type
, i
);
13395 /* Complain if virtual function table field not found. */
13396 if (i
< TYPE_N_BASECLASSES (t
))
13397 complaint (&symfile_complaints
,
13398 _("virtual function table pointer "
13399 "not found when defining class '%s'"),
13400 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
13405 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
13408 else if (cu
->producer
13409 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
13411 /* The IBM XLC compiler does not provide direct indication
13412 of the containing type, but the vtable pointer is
13413 always named __vfp. */
13417 for (i
= TYPE_NFIELDS (type
) - 1;
13418 i
>= TYPE_N_BASECLASSES (type
);
13421 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
13423 set_type_vptr_fieldno (type
, i
);
13424 set_type_vptr_basetype (type
, type
);
13431 /* Copy fi.typedef_field_list linked list elements content into the
13432 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13433 if (fi
.typedef_field_list
)
13435 int i
= fi
.typedef_field_list_count
;
13437 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13438 TYPE_TYPEDEF_FIELD_ARRAY (type
)
13439 = ((struct typedef_field
*)
13440 TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
));
13441 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
13443 /* Reverse the list order to keep the debug info elements order. */
13446 struct typedef_field
*dest
, *src
;
13448 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
13449 src
= &fi
.typedef_field_list
->field
;
13450 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
13455 do_cleanups (back_to
);
13458 quirk_gcc_member_function_pointer (type
, objfile
);
13460 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13461 snapshots) has been known to create a die giving a declaration
13462 for a class that has, as a child, a die giving a definition for a
13463 nested class. So we have to process our children even if the
13464 current die is a declaration. Normally, of course, a declaration
13465 won't have any children at all. */
13467 child_die
= die
->child
;
13469 while (child_die
!= NULL
&& child_die
->tag
)
13471 if (child_die
->tag
== DW_TAG_member
13472 || child_die
->tag
== DW_TAG_variable
13473 || child_die
->tag
== DW_TAG_inheritance
13474 || child_die
->tag
== DW_TAG_template_value_param
13475 || child_die
->tag
== DW_TAG_template_type_param
)
13480 process_die (child_die
, cu
);
13482 child_die
= sibling_die (child_die
);
13485 /* Do not consider external references. According to the DWARF standard,
13486 these DIEs are identified by the fact that they have no byte_size
13487 attribute, and a declaration attribute. */
13488 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
13489 || !die_is_declaration (die
, cu
))
13490 new_symbol (die
, type
, cu
);
13493 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13494 update TYPE using some information only available in DIE's children. */
13497 update_enumeration_type_from_children (struct die_info
*die
,
13499 struct dwarf2_cu
*cu
)
13501 struct obstack obstack
;
13502 struct die_info
*child_die
;
13503 int unsigned_enum
= 1;
13506 struct cleanup
*old_chain
;
13508 obstack_init (&obstack
);
13509 old_chain
= make_cleanup_obstack_free (&obstack
);
13511 for (child_die
= die
->child
;
13512 child_die
!= NULL
&& child_die
->tag
;
13513 child_die
= sibling_die (child_die
))
13515 struct attribute
*attr
;
13517 const gdb_byte
*bytes
;
13518 struct dwarf2_locexpr_baton
*baton
;
13521 if (child_die
->tag
!= DW_TAG_enumerator
)
13524 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
13528 name
= dwarf2_name (child_die
, cu
);
13530 name
= "<anonymous enumerator>";
13532 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
13533 &value
, &bytes
, &baton
);
13539 else if ((mask
& value
) != 0)
13544 /* If we already know that the enum type is neither unsigned, nor
13545 a flag type, no need to look at the rest of the enumerates. */
13546 if (!unsigned_enum
&& !flag_enum
)
13551 TYPE_UNSIGNED (type
) = 1;
13553 TYPE_FLAG_ENUM (type
) = 1;
13555 do_cleanups (old_chain
);
13558 /* Given a DW_AT_enumeration_type die, set its type. We do not
13559 complete the type's fields yet, or create any symbols. */
13561 static struct type
*
13562 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13564 struct objfile
*objfile
= cu
->objfile
;
13566 struct attribute
*attr
;
13569 /* If the definition of this type lives in .debug_types, read that type.
13570 Don't follow DW_AT_specification though, that will take us back up
13571 the chain and we want to go down. */
13572 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13575 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13577 /* The type's CU may not be the same as CU.
13578 Ensure TYPE is recorded with CU in die_type_hash. */
13579 return set_die_type (die
, type
, cu
);
13582 type
= alloc_type (objfile
);
13584 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
13585 name
= dwarf2_full_name (NULL
, die
, cu
);
13587 TYPE_TAG_NAME (type
) = name
;
13589 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13592 struct type
*underlying_type
= die_type (die
, cu
);
13594 TYPE_TARGET_TYPE (type
) = underlying_type
;
13597 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13600 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13604 TYPE_LENGTH (type
) = 0;
13607 /* The enumeration DIE can be incomplete. In Ada, any type can be
13608 declared as private in the package spec, and then defined only
13609 inside the package body. Such types are known as Taft Amendment
13610 Types. When another package uses such a type, an incomplete DIE
13611 may be generated by the compiler. */
13612 if (die_is_declaration (die
, cu
))
13613 TYPE_STUB (type
) = 1;
13615 /* Finish the creation of this type by using the enum's children.
13616 We must call this even when the underlying type has been provided
13617 so that we can determine if we're looking at a "flag" enum. */
13618 update_enumeration_type_from_children (die
, type
, cu
);
13620 /* If this type has an underlying type that is not a stub, then we
13621 may use its attributes. We always use the "unsigned" attribute
13622 in this situation, because ordinarily we guess whether the type
13623 is unsigned -- but the guess can be wrong and the underlying type
13624 can tell us the reality. However, we defer to a local size
13625 attribute if one exists, because this lets the compiler override
13626 the underlying type if needed. */
13627 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
13629 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
13630 if (TYPE_LENGTH (type
) == 0)
13631 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
13634 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
13636 return set_die_type (die
, type
, cu
);
13639 /* Given a pointer to a die which begins an enumeration, process all
13640 the dies that define the members of the enumeration, and create the
13641 symbol for the enumeration type.
13643 NOTE: We reverse the order of the element list. */
13646 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13648 struct type
*this_type
;
13650 this_type
= get_die_type (die
, cu
);
13651 if (this_type
== NULL
)
13652 this_type
= read_enumeration_type (die
, cu
);
13654 if (die
->child
!= NULL
)
13656 struct die_info
*child_die
;
13657 struct symbol
*sym
;
13658 struct field
*fields
= NULL
;
13659 int num_fields
= 0;
13662 child_die
= die
->child
;
13663 while (child_die
&& child_die
->tag
)
13665 if (child_die
->tag
!= DW_TAG_enumerator
)
13667 process_die (child_die
, cu
);
13671 name
= dwarf2_name (child_die
, cu
);
13674 sym
= new_symbol (child_die
, this_type
, cu
);
13676 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
13678 fields
= (struct field
*)
13680 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
13681 * sizeof (struct field
));
13684 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
13685 FIELD_TYPE (fields
[num_fields
]) = NULL
;
13686 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
13687 FIELD_BITSIZE (fields
[num_fields
]) = 0;
13693 child_die
= sibling_die (child_die
);
13698 TYPE_NFIELDS (this_type
) = num_fields
;
13699 TYPE_FIELDS (this_type
) = (struct field
*)
13700 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
13701 memcpy (TYPE_FIELDS (this_type
), fields
,
13702 sizeof (struct field
) * num_fields
);
13707 /* If we are reading an enum from a .debug_types unit, and the enum
13708 is a declaration, and the enum is not the signatured type in the
13709 unit, then we do not want to add a symbol for it. Adding a
13710 symbol would in some cases obscure the true definition of the
13711 enum, giving users an incomplete type when the definition is
13712 actually available. Note that we do not want to do this for all
13713 enums which are just declarations, because C++0x allows forward
13714 enum declarations. */
13715 if (cu
->per_cu
->is_debug_types
13716 && die_is_declaration (die
, cu
))
13718 struct signatured_type
*sig_type
;
13720 sig_type
= (struct signatured_type
*) cu
->per_cu
;
13721 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
13722 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
13726 new_symbol (die
, this_type
, cu
);
13729 /* Extract all information from a DW_TAG_array_type DIE and put it in
13730 the DIE's type field. For now, this only handles one dimensional
13733 static struct type
*
13734 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13736 struct objfile
*objfile
= cu
->objfile
;
13737 struct die_info
*child_die
;
13739 struct type
*element_type
, *range_type
, *index_type
;
13740 struct type
**range_types
= NULL
;
13741 struct attribute
*attr
;
13743 struct cleanup
*back_to
;
13745 unsigned int bit_stride
= 0;
13747 element_type
= die_type (die
, cu
);
13749 /* The die_type call above may have already set the type for this DIE. */
13750 type
= get_die_type (die
, cu
);
13754 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
13756 bit_stride
= DW_UNSND (attr
) * 8;
13758 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
13760 bit_stride
= DW_UNSND (attr
);
13762 /* Irix 6.2 native cc creates array types without children for
13763 arrays with unspecified length. */
13764 if (die
->child
== NULL
)
13766 index_type
= objfile_type (objfile
)->builtin_int
;
13767 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
13768 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
13770 return set_die_type (die
, type
, cu
);
13773 back_to
= make_cleanup (null_cleanup
, NULL
);
13774 child_die
= die
->child
;
13775 while (child_die
&& child_die
->tag
)
13777 if (child_die
->tag
== DW_TAG_subrange_type
)
13779 struct type
*child_type
= read_type_die (child_die
, cu
);
13781 if (child_type
!= NULL
)
13783 /* The range type was succesfully read. Save it for the
13784 array type creation. */
13785 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
13787 range_types
= (struct type
**)
13788 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
13789 * sizeof (struct type
*));
13791 make_cleanup (free_current_contents
, &range_types
);
13793 range_types
[ndim
++] = child_type
;
13796 child_die
= sibling_die (child_die
);
13799 /* Dwarf2 dimensions are output from left to right, create the
13800 necessary array types in backwards order. */
13802 type
= element_type
;
13804 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
13809 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
13815 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
13819 /* Understand Dwarf2 support for vector types (like they occur on
13820 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13821 array type. This is not part of the Dwarf2/3 standard yet, but a
13822 custom vendor extension. The main difference between a regular
13823 array and the vector variant is that vectors are passed by value
13825 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
13827 make_vector_type (type
);
13829 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13830 implementation may choose to implement triple vectors using this
13832 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13835 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
13836 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13838 complaint (&symfile_complaints
,
13839 _("DW_AT_byte_size for array type smaller "
13840 "than the total size of elements"));
13843 name
= dwarf2_name (die
, cu
);
13845 TYPE_NAME (type
) = name
;
13847 /* Install the type in the die. */
13848 set_die_type (die
, type
, cu
);
13850 /* set_die_type should be already done. */
13851 set_descriptive_type (type
, die
, cu
);
13853 do_cleanups (back_to
);
13858 static enum dwarf_array_dim_ordering
13859 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
13861 struct attribute
*attr
;
13863 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
13866 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
13868 /* GNU F77 is a special case, as at 08/2004 array type info is the
13869 opposite order to the dwarf2 specification, but data is still
13870 laid out as per normal fortran.
13872 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13873 version checking. */
13875 if (cu
->language
== language_fortran
13876 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
13878 return DW_ORD_row_major
;
13881 switch (cu
->language_defn
->la_array_ordering
)
13883 case array_column_major
:
13884 return DW_ORD_col_major
;
13885 case array_row_major
:
13887 return DW_ORD_row_major
;
13891 /* Extract all information from a DW_TAG_set_type DIE and put it in
13892 the DIE's type field. */
13894 static struct type
*
13895 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13897 struct type
*domain_type
, *set_type
;
13898 struct attribute
*attr
;
13900 domain_type
= die_type (die
, cu
);
13902 /* The die_type call above may have already set the type for this DIE. */
13903 set_type
= get_die_type (die
, cu
);
13907 set_type
= create_set_type (NULL
, domain_type
);
13909 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13911 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
13913 return set_die_type (die
, set_type
, cu
);
13916 /* A helper for read_common_block that creates a locexpr baton.
13917 SYM is the symbol which we are marking as computed.
13918 COMMON_DIE is the DIE for the common block.
13919 COMMON_LOC is the location expression attribute for the common
13921 MEMBER_LOC is the location expression attribute for the particular
13922 member of the common block that we are processing.
13923 CU is the CU from which the above come. */
13926 mark_common_block_symbol_computed (struct symbol
*sym
,
13927 struct die_info
*common_die
,
13928 struct attribute
*common_loc
,
13929 struct attribute
*member_loc
,
13930 struct dwarf2_cu
*cu
)
13932 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13933 struct dwarf2_locexpr_baton
*baton
;
13935 unsigned int cu_off
;
13936 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
13937 LONGEST offset
= 0;
13939 gdb_assert (common_loc
&& member_loc
);
13940 gdb_assert (attr_form_is_block (common_loc
));
13941 gdb_assert (attr_form_is_block (member_loc
)
13942 || attr_form_is_constant (member_loc
));
13944 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13945 baton
->per_cu
= cu
->per_cu
;
13946 gdb_assert (baton
->per_cu
);
13948 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13950 if (attr_form_is_constant (member_loc
))
13952 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
13953 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
13956 baton
->size
+= DW_BLOCK (member_loc
)->size
;
13958 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
13961 *ptr
++ = DW_OP_call4
;
13962 cu_off
= common_die
->offset
.sect_off
- cu
->per_cu
->offset
.sect_off
;
13963 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
13966 if (attr_form_is_constant (member_loc
))
13968 *ptr
++ = DW_OP_addr
;
13969 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
13970 ptr
+= cu
->header
.addr_size
;
13974 /* We have to copy the data here, because DW_OP_call4 will only
13975 use a DW_AT_location attribute. */
13976 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
13977 ptr
+= DW_BLOCK (member_loc
)->size
;
13980 *ptr
++ = DW_OP_plus
;
13981 gdb_assert (ptr
- baton
->data
== baton
->size
);
13983 SYMBOL_LOCATION_BATON (sym
) = baton
;
13984 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
13987 /* Create appropriate locally-scoped variables for all the
13988 DW_TAG_common_block entries. Also create a struct common_block
13989 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13990 is used to sepate the common blocks name namespace from regular
13994 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
13996 struct attribute
*attr
;
13998 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
14001 /* Support the .debug_loc offsets. */
14002 if (attr_form_is_block (attr
))
14006 else if (attr_form_is_section_offset (attr
))
14008 dwarf2_complex_location_expr_complaint ();
14013 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14014 "common block member");
14019 if (die
->child
!= NULL
)
14021 struct objfile
*objfile
= cu
->objfile
;
14022 struct die_info
*child_die
;
14023 size_t n_entries
= 0, size
;
14024 struct common_block
*common_block
;
14025 struct symbol
*sym
;
14027 for (child_die
= die
->child
;
14028 child_die
&& child_die
->tag
;
14029 child_die
= sibling_die (child_die
))
14032 size
= (sizeof (struct common_block
)
14033 + (n_entries
- 1) * sizeof (struct symbol
*));
14035 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
14037 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
14038 common_block
->n_entries
= 0;
14040 for (child_die
= die
->child
;
14041 child_die
&& child_die
->tag
;
14042 child_die
= sibling_die (child_die
))
14044 /* Create the symbol in the DW_TAG_common_block block in the current
14046 sym
= new_symbol (child_die
, NULL
, cu
);
14049 struct attribute
*member_loc
;
14051 common_block
->contents
[common_block
->n_entries
++] = sym
;
14053 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
14057 /* GDB has handled this for a long time, but it is
14058 not specified by DWARF. It seems to have been
14059 emitted by gfortran at least as recently as:
14060 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
14061 complaint (&symfile_complaints
,
14062 _("Variable in common block has "
14063 "DW_AT_data_member_location "
14064 "- DIE at 0x%x [in module %s]"),
14065 child_die
->offset
.sect_off
,
14066 objfile_name (cu
->objfile
));
14068 if (attr_form_is_section_offset (member_loc
))
14069 dwarf2_complex_location_expr_complaint ();
14070 else if (attr_form_is_constant (member_loc
)
14071 || attr_form_is_block (member_loc
))
14074 mark_common_block_symbol_computed (sym
, die
, attr
,
14078 dwarf2_complex_location_expr_complaint ();
14083 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
14084 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
14088 /* Create a type for a C++ namespace. */
14090 static struct type
*
14091 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14093 struct objfile
*objfile
= cu
->objfile
;
14094 const char *previous_prefix
, *name
;
14098 /* For extensions, reuse the type of the original namespace. */
14099 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
14101 struct die_info
*ext_die
;
14102 struct dwarf2_cu
*ext_cu
= cu
;
14104 ext_die
= dwarf2_extension (die
, &ext_cu
);
14105 type
= read_type_die (ext_die
, ext_cu
);
14107 /* EXT_CU may not be the same as CU.
14108 Ensure TYPE is recorded with CU in die_type_hash. */
14109 return set_die_type (die
, type
, cu
);
14112 name
= namespace_name (die
, &is_anonymous
, cu
);
14114 /* Now build the name of the current namespace. */
14116 previous_prefix
= determine_prefix (die
, cu
);
14117 if (previous_prefix
[0] != '\0')
14118 name
= typename_concat (&objfile
->objfile_obstack
,
14119 previous_prefix
, name
, 0, cu
);
14121 /* Create the type. */
14122 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
14123 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14125 return set_die_type (die
, type
, cu
);
14128 /* Read a namespace scope. */
14131 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
14133 struct objfile
*objfile
= cu
->objfile
;
14136 /* Add a symbol associated to this if we haven't seen the namespace
14137 before. Also, add a using directive if it's an anonymous
14140 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
14144 type
= read_type_die (die
, cu
);
14145 new_symbol (die
, type
, cu
);
14147 namespace_name (die
, &is_anonymous
, cu
);
14150 const char *previous_prefix
= determine_prefix (die
, cu
);
14152 add_using_directive (using_directives (cu
->language
),
14153 previous_prefix
, TYPE_NAME (type
), NULL
,
14154 NULL
, NULL
, 0, &objfile
->objfile_obstack
);
14158 if (die
->child
!= NULL
)
14160 struct die_info
*child_die
= die
->child
;
14162 while (child_die
&& child_die
->tag
)
14164 process_die (child_die
, cu
);
14165 child_die
= sibling_die (child_die
);
14170 /* Read a Fortran module as type. This DIE can be only a declaration used for
14171 imported module. Still we need that type as local Fortran "use ... only"
14172 declaration imports depend on the created type in determine_prefix. */
14174 static struct type
*
14175 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14177 struct objfile
*objfile
= cu
->objfile
;
14178 const char *module_name
;
14181 module_name
= dwarf2_name (die
, cu
);
14183 complaint (&symfile_complaints
,
14184 _("DW_TAG_module has no name, offset 0x%x"),
14185 die
->offset
.sect_off
);
14186 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
14188 /* determine_prefix uses TYPE_TAG_NAME. */
14189 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14191 return set_die_type (die
, type
, cu
);
14194 /* Read a Fortran module. */
14197 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
14199 struct die_info
*child_die
= die
->child
;
14202 type
= read_type_die (die
, cu
);
14203 new_symbol (die
, type
, cu
);
14205 while (child_die
&& child_die
->tag
)
14207 process_die (child_die
, cu
);
14208 child_die
= sibling_die (child_die
);
14212 /* Return the name of the namespace represented by DIE. Set
14213 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
14216 static const char *
14217 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
14219 struct die_info
*current_die
;
14220 const char *name
= NULL
;
14222 /* Loop through the extensions until we find a name. */
14224 for (current_die
= die
;
14225 current_die
!= NULL
;
14226 current_die
= dwarf2_extension (die
, &cu
))
14228 /* We don't use dwarf2_name here so that we can detect the absence
14229 of a name -> anonymous namespace. */
14230 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
14236 /* Is it an anonymous namespace? */
14238 *is_anonymous
= (name
== NULL
);
14240 name
= CP_ANONYMOUS_NAMESPACE_STR
;
14245 /* Extract all information from a DW_TAG_pointer_type DIE and add to
14246 the user defined type vector. */
14248 static struct type
*
14249 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14251 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
14252 struct comp_unit_head
*cu_header
= &cu
->header
;
14254 struct attribute
*attr_byte_size
;
14255 struct attribute
*attr_address_class
;
14256 int byte_size
, addr_class
;
14257 struct type
*target_type
;
14259 target_type
= die_type (die
, cu
);
14261 /* The die_type call above may have already set the type for this DIE. */
14262 type
= get_die_type (die
, cu
);
14266 type
= lookup_pointer_type (target_type
);
14268 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14269 if (attr_byte_size
)
14270 byte_size
= DW_UNSND (attr_byte_size
);
14272 byte_size
= cu_header
->addr_size
;
14274 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
14275 if (attr_address_class
)
14276 addr_class
= DW_UNSND (attr_address_class
);
14278 addr_class
= DW_ADDR_none
;
14280 /* If the pointer size or address class is different than the
14281 default, create a type variant marked as such and set the
14282 length accordingly. */
14283 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
14285 if (gdbarch_address_class_type_flags_p (gdbarch
))
14289 type_flags
= gdbarch_address_class_type_flags
14290 (gdbarch
, byte_size
, addr_class
);
14291 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
14293 type
= make_type_with_address_space (type
, type_flags
);
14295 else if (TYPE_LENGTH (type
) != byte_size
)
14297 complaint (&symfile_complaints
,
14298 _("invalid pointer size %d"), byte_size
);
14302 /* Should we also complain about unhandled address classes? */
14306 TYPE_LENGTH (type
) = byte_size
;
14307 return set_die_type (die
, type
, cu
);
14310 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14311 the user defined type vector. */
14313 static struct type
*
14314 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14317 struct type
*to_type
;
14318 struct type
*domain
;
14320 to_type
= die_type (die
, cu
);
14321 domain
= die_containing_type (die
, cu
);
14323 /* The calls above may have already set the type for this DIE. */
14324 type
= get_die_type (die
, cu
);
14328 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
14329 type
= lookup_methodptr_type (to_type
);
14330 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
14332 struct type
*new_type
= alloc_type (cu
->objfile
);
14334 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
14335 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
14336 TYPE_VARARGS (to_type
));
14337 type
= lookup_methodptr_type (new_type
);
14340 type
= lookup_memberptr_type (to_type
, domain
);
14342 return set_die_type (die
, type
, cu
);
14345 /* Extract all information from a DW_TAG_reference_type DIE and add to
14346 the user defined type vector. */
14348 static struct type
*
14349 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14351 struct comp_unit_head
*cu_header
= &cu
->header
;
14352 struct type
*type
, *target_type
;
14353 struct attribute
*attr
;
14355 target_type
= die_type (die
, cu
);
14357 /* The die_type call above may have already set the type for this DIE. */
14358 type
= get_die_type (die
, cu
);
14362 type
= lookup_reference_type (target_type
);
14363 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14366 TYPE_LENGTH (type
) = DW_UNSND (attr
);
14370 TYPE_LENGTH (type
) = cu_header
->addr_size
;
14372 return set_die_type (die
, type
, cu
);
14375 /* Add the given cv-qualifiers to the element type of the array. GCC
14376 outputs DWARF type qualifiers that apply to an array, not the
14377 element type. But GDB relies on the array element type to carry
14378 the cv-qualifiers. This mimics section 6.7.3 of the C99
14381 static struct type
*
14382 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
14383 struct type
*base_type
, int cnst
, int voltl
)
14385 struct type
*el_type
, *inner_array
;
14387 base_type
= copy_type (base_type
);
14388 inner_array
= base_type
;
14390 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
14392 TYPE_TARGET_TYPE (inner_array
) =
14393 copy_type (TYPE_TARGET_TYPE (inner_array
));
14394 inner_array
= TYPE_TARGET_TYPE (inner_array
);
14397 el_type
= TYPE_TARGET_TYPE (inner_array
);
14398 cnst
|= TYPE_CONST (el_type
);
14399 voltl
|= TYPE_VOLATILE (el_type
);
14400 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
14402 return set_die_type (die
, base_type
, cu
);
14405 static struct type
*
14406 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14408 struct type
*base_type
, *cv_type
;
14410 base_type
= die_type (die
, cu
);
14412 /* The die_type call above may have already set the type for this DIE. */
14413 cv_type
= get_die_type (die
, cu
);
14417 /* In case the const qualifier is applied to an array type, the element type
14418 is so qualified, not the array type (section 6.7.3 of C99). */
14419 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14420 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
14422 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
14423 return set_die_type (die
, cv_type
, cu
);
14426 static struct type
*
14427 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14429 struct type
*base_type
, *cv_type
;
14431 base_type
= die_type (die
, cu
);
14433 /* The die_type call above may have already set the type for this DIE. */
14434 cv_type
= get_die_type (die
, cu
);
14438 /* In case the volatile qualifier is applied to an array type, the
14439 element type is so qualified, not the array type (section 6.7.3
14441 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14442 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
14444 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
14445 return set_die_type (die
, cv_type
, cu
);
14448 /* Handle DW_TAG_restrict_type. */
14450 static struct type
*
14451 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14453 struct type
*base_type
, *cv_type
;
14455 base_type
= die_type (die
, cu
);
14457 /* The die_type call above may have already set the type for this DIE. */
14458 cv_type
= get_die_type (die
, cu
);
14462 cv_type
= make_restrict_type (base_type
);
14463 return set_die_type (die
, cv_type
, cu
);
14466 /* Handle DW_TAG_atomic_type. */
14468 static struct type
*
14469 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14471 struct type
*base_type
, *cv_type
;
14473 base_type
= die_type (die
, cu
);
14475 /* The die_type call above may have already set the type for this DIE. */
14476 cv_type
= get_die_type (die
, cu
);
14480 cv_type
= make_atomic_type (base_type
);
14481 return set_die_type (die
, cv_type
, cu
);
14484 /* Extract all information from a DW_TAG_string_type DIE and add to
14485 the user defined type vector. It isn't really a user defined type,
14486 but it behaves like one, with other DIE's using an AT_user_def_type
14487 attribute to reference it. */
14489 static struct type
*
14490 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14492 struct objfile
*objfile
= cu
->objfile
;
14493 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14494 struct type
*type
, *range_type
, *index_type
, *char_type
;
14495 struct attribute
*attr
;
14496 unsigned int length
;
14498 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
14501 length
= DW_UNSND (attr
);
14505 /* Check for the DW_AT_byte_size attribute. */
14506 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14509 length
= DW_UNSND (attr
);
14517 index_type
= objfile_type (objfile
)->builtin_int
;
14518 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
14519 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
14520 type
= create_string_type (NULL
, char_type
, range_type
);
14522 return set_die_type (die
, type
, cu
);
14525 /* Assuming that DIE corresponds to a function, returns nonzero
14526 if the function is prototyped. */
14529 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
14531 struct attribute
*attr
;
14533 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
14534 if (attr
&& (DW_UNSND (attr
) != 0))
14537 /* The DWARF standard implies that the DW_AT_prototyped attribute
14538 is only meaninful for C, but the concept also extends to other
14539 languages that allow unprototyped functions (Eg: Objective C).
14540 For all other languages, assume that functions are always
14542 if (cu
->language
!= language_c
14543 && cu
->language
!= language_objc
14544 && cu
->language
!= language_opencl
)
14547 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14548 prototyped and unprototyped functions; default to prototyped,
14549 since that is more common in modern code (and RealView warns
14550 about unprototyped functions). */
14551 if (producer_is_realview (cu
->producer
))
14557 /* Handle DIES due to C code like:
14561 int (*funcp)(int a, long l);
14565 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14567 static struct type
*
14568 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14570 struct objfile
*objfile
= cu
->objfile
;
14571 struct type
*type
; /* Type that this function returns. */
14572 struct type
*ftype
; /* Function that returns above type. */
14573 struct attribute
*attr
;
14575 type
= die_type (die
, cu
);
14577 /* The die_type call above may have already set the type for this DIE. */
14578 ftype
= get_die_type (die
, cu
);
14582 ftype
= lookup_function_type (type
);
14584 if (prototyped_function_p (die
, cu
))
14585 TYPE_PROTOTYPED (ftype
) = 1;
14587 /* Store the calling convention in the type if it's available in
14588 the subroutine die. Otherwise set the calling convention to
14589 the default value DW_CC_normal. */
14590 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
14592 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
14593 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
14594 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
14596 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
14598 /* Record whether the function returns normally to its caller or not
14599 if the DWARF producer set that information. */
14600 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
14601 if (attr
&& (DW_UNSND (attr
) != 0))
14602 TYPE_NO_RETURN (ftype
) = 1;
14604 /* We need to add the subroutine type to the die immediately so
14605 we don't infinitely recurse when dealing with parameters
14606 declared as the same subroutine type. */
14607 set_die_type (die
, ftype
, cu
);
14609 if (die
->child
!= NULL
)
14611 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
14612 struct die_info
*child_die
;
14613 int nparams
, iparams
;
14615 /* Count the number of parameters.
14616 FIXME: GDB currently ignores vararg functions, but knows about
14617 vararg member functions. */
14619 child_die
= die
->child
;
14620 while (child_die
&& child_die
->tag
)
14622 if (child_die
->tag
== DW_TAG_formal_parameter
)
14624 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
14625 TYPE_VARARGS (ftype
) = 1;
14626 child_die
= sibling_die (child_die
);
14629 /* Allocate storage for parameters and fill them in. */
14630 TYPE_NFIELDS (ftype
) = nparams
;
14631 TYPE_FIELDS (ftype
) = (struct field
*)
14632 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
14634 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14635 even if we error out during the parameters reading below. */
14636 for (iparams
= 0; iparams
< nparams
; iparams
++)
14637 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
14640 child_die
= die
->child
;
14641 while (child_die
&& child_die
->tag
)
14643 if (child_die
->tag
== DW_TAG_formal_parameter
)
14645 struct type
*arg_type
;
14647 /* DWARF version 2 has no clean way to discern C++
14648 static and non-static member functions. G++ helps
14649 GDB by marking the first parameter for non-static
14650 member functions (which is the this pointer) as
14651 artificial. We pass this information to
14652 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14654 DWARF version 3 added DW_AT_object_pointer, which GCC
14655 4.5 does not yet generate. */
14656 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
14658 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
14660 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
14661 arg_type
= die_type (child_die
, cu
);
14663 /* RealView does not mark THIS as const, which the testsuite
14664 expects. GCC marks THIS as const in method definitions,
14665 but not in the class specifications (GCC PR 43053). */
14666 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
14667 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
14670 struct dwarf2_cu
*arg_cu
= cu
;
14671 const char *name
= dwarf2_name (child_die
, cu
);
14673 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
14676 /* If the compiler emits this, use it. */
14677 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
14680 else if (name
&& strcmp (name
, "this") == 0)
14681 /* Function definitions will have the argument names. */
14683 else if (name
== NULL
&& iparams
== 0)
14684 /* Declarations may not have the names, so like
14685 elsewhere in GDB, assume an artificial first
14686 argument is "this". */
14690 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
14694 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
14697 child_die
= sibling_die (child_die
);
14704 static struct type
*
14705 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
14707 struct objfile
*objfile
= cu
->objfile
;
14708 const char *name
= NULL
;
14709 struct type
*this_type
, *target_type
;
14711 name
= dwarf2_full_name (NULL
, die
, cu
);
14712 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
14713 TYPE_TARGET_STUB (this_type
) = 1;
14714 set_die_type (die
, this_type
, cu
);
14715 target_type
= die_type (die
, cu
);
14716 if (target_type
!= this_type
)
14717 TYPE_TARGET_TYPE (this_type
) = target_type
;
14720 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14721 spec and cause infinite loops in GDB. */
14722 complaint (&symfile_complaints
,
14723 _("Self-referential DW_TAG_typedef "
14724 "- DIE at 0x%x [in module %s]"),
14725 die
->offset
.sect_off
, objfile_name (objfile
));
14726 TYPE_TARGET_TYPE (this_type
) = NULL
;
14731 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
14732 (which may be different from NAME) to the architecture back-end to allow
14733 it to guess the correct format if necessary. */
14735 static struct type
*
14736 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
14737 const char *name_hint
)
14739 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14740 const struct floatformat
**format
;
14743 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
14745 type
= init_float_type (objfile
, bits
, name
, format
);
14747 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
/ TARGET_CHAR_BIT
, name
);
14752 /* Find a representation of a given base type and install
14753 it in the TYPE field of the die. */
14755 static struct type
*
14756 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14758 struct objfile
*objfile
= cu
->objfile
;
14760 struct attribute
*attr
;
14761 int encoding
= 0, bits
= 0;
14764 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
14767 encoding
= DW_UNSND (attr
);
14769 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14772 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
14774 name
= dwarf2_name (die
, cu
);
14777 complaint (&symfile_complaints
,
14778 _("DW_AT_name missing from DW_TAG_base_type"));
14783 case DW_ATE_address
:
14784 /* Turn DW_ATE_address into a void * pointer. */
14785 type
= init_type (objfile
, TYPE_CODE_VOID
, 1, NULL
);
14786 type
= init_pointer_type (objfile
, bits
, name
, type
);
14788 case DW_ATE_boolean
:
14789 type
= init_boolean_type (objfile
, bits
, 1, name
);
14791 case DW_ATE_complex_float
:
14792 type
= dwarf2_init_float_type (objfile
, bits
/ 2, NULL
, name
);
14793 type
= init_complex_type (objfile
, name
, type
);
14795 case DW_ATE_decimal_float
:
14796 type
= init_decfloat_type (objfile
, bits
, name
);
14799 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
);
14801 case DW_ATE_signed
:
14802 type
= init_integer_type (objfile
, bits
, 0, name
);
14804 case DW_ATE_unsigned
:
14805 if (cu
->language
== language_fortran
14807 && startswith (name
, "character("))
14808 type
= init_character_type (objfile
, bits
, 1, name
);
14810 type
= init_integer_type (objfile
, bits
, 1, name
);
14812 case DW_ATE_signed_char
:
14813 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14814 || cu
->language
== language_pascal
14815 || cu
->language
== language_fortran
)
14816 type
= init_character_type (objfile
, bits
, 0, name
);
14818 type
= init_integer_type (objfile
, bits
, 0, name
);
14820 case DW_ATE_unsigned_char
:
14821 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14822 || cu
->language
== language_pascal
14823 || cu
->language
== language_fortran
14824 || cu
->language
== language_rust
)
14825 type
= init_character_type (objfile
, bits
, 1, name
);
14827 type
= init_integer_type (objfile
, bits
, 1, name
);
14830 /* We just treat this as an integer and then recognize the
14831 type by name elsewhere. */
14832 type
= init_integer_type (objfile
, bits
, 0, name
);
14836 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
14837 dwarf_type_encoding_name (encoding
));
14838 type
= init_type (objfile
, TYPE_CODE_ERROR
,
14839 bits
/ TARGET_CHAR_BIT
, name
);
14843 if (name
&& strcmp (name
, "char") == 0)
14844 TYPE_NOSIGN (type
) = 1;
14846 return set_die_type (die
, type
, cu
);
14849 /* Parse dwarf attribute if it's a block, reference or constant and put the
14850 resulting value of the attribute into struct bound_prop.
14851 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14854 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
14855 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
14857 struct dwarf2_property_baton
*baton
;
14858 struct obstack
*obstack
= &cu
->objfile
->objfile_obstack
;
14860 if (attr
== NULL
|| prop
== NULL
)
14863 if (attr_form_is_block (attr
))
14865 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
14866 baton
->referenced_type
= NULL
;
14867 baton
->locexpr
.per_cu
= cu
->per_cu
;
14868 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
14869 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
14870 prop
->data
.baton
= baton
;
14871 prop
->kind
= PROP_LOCEXPR
;
14872 gdb_assert (prop
->data
.baton
!= NULL
);
14874 else if (attr_form_is_ref (attr
))
14876 struct dwarf2_cu
*target_cu
= cu
;
14877 struct die_info
*target_die
;
14878 struct attribute
*target_attr
;
14880 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14881 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
14882 if (target_attr
== NULL
)
14883 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
14885 if (target_attr
== NULL
)
14888 switch (target_attr
->name
)
14890 case DW_AT_location
:
14891 if (attr_form_is_section_offset (target_attr
))
14893 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
14894 baton
->referenced_type
= die_type (target_die
, target_cu
);
14895 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
14896 prop
->data
.baton
= baton
;
14897 prop
->kind
= PROP_LOCLIST
;
14898 gdb_assert (prop
->data
.baton
!= NULL
);
14900 else if (attr_form_is_block (target_attr
))
14902 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
14903 baton
->referenced_type
= die_type (target_die
, target_cu
);
14904 baton
->locexpr
.per_cu
= cu
->per_cu
;
14905 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
14906 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
14907 prop
->data
.baton
= baton
;
14908 prop
->kind
= PROP_LOCEXPR
;
14909 gdb_assert (prop
->data
.baton
!= NULL
);
14913 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14914 "dynamic property");
14918 case DW_AT_data_member_location
:
14922 if (!handle_data_member_location (target_die
, target_cu
,
14926 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
14927 baton
->referenced_type
= read_type_die (target_die
->parent
,
14929 baton
->offset_info
.offset
= offset
;
14930 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
14931 prop
->data
.baton
= baton
;
14932 prop
->kind
= PROP_ADDR_OFFSET
;
14937 else if (attr_form_is_constant (attr
))
14939 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
14940 prop
->kind
= PROP_CONST
;
14944 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
14945 dwarf2_name (die
, cu
));
14952 /* Read the given DW_AT_subrange DIE. */
14954 static struct type
*
14955 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14957 struct type
*base_type
, *orig_base_type
;
14958 struct type
*range_type
;
14959 struct attribute
*attr
;
14960 struct dynamic_prop low
, high
;
14961 int low_default_is_valid
;
14962 int high_bound_is_count
= 0;
14964 LONGEST negative_mask
;
14966 orig_base_type
= die_type (die
, cu
);
14967 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14968 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14969 creating the range type, but we use the result of check_typedef
14970 when examining properties of the type. */
14971 base_type
= check_typedef (orig_base_type
);
14973 /* The die_type call above may have already set the type for this DIE. */
14974 range_type
= get_die_type (die
, cu
);
14978 low
.kind
= PROP_CONST
;
14979 high
.kind
= PROP_CONST
;
14980 high
.data
.const_val
= 0;
14982 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14983 omitting DW_AT_lower_bound. */
14984 switch (cu
->language
)
14987 case language_cplus
:
14988 low
.data
.const_val
= 0;
14989 low_default_is_valid
= 1;
14991 case language_fortran
:
14992 low
.data
.const_val
= 1;
14993 low_default_is_valid
= 1;
14996 case language_objc
:
14997 case language_rust
:
14998 low
.data
.const_val
= 0;
14999 low_default_is_valid
= (cu
->header
.version
>= 4);
15003 case language_pascal
:
15004 low
.data
.const_val
= 1;
15005 low_default_is_valid
= (cu
->header
.version
>= 4);
15008 low
.data
.const_val
= 0;
15009 low_default_is_valid
= 0;
15013 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
15015 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
15016 else if (!low_default_is_valid
)
15017 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
15018 "- DIE at 0x%x [in module %s]"),
15019 die
->offset
.sect_off
, objfile_name (cu
->objfile
));
15021 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
15022 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
15024 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
15025 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
15027 /* If bounds are constant do the final calculation here. */
15028 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
15029 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
15031 high_bound_is_count
= 1;
15035 /* Dwarf-2 specifications explicitly allows to create subrange types
15036 without specifying a base type.
15037 In that case, the base type must be set to the type of
15038 the lower bound, upper bound or count, in that order, if any of these
15039 three attributes references an object that has a type.
15040 If no base type is found, the Dwarf-2 specifications say that
15041 a signed integer type of size equal to the size of an address should
15043 For the following C code: `extern char gdb_int [];'
15044 GCC produces an empty range DIE.
15045 FIXME: muller/2010-05-28: Possible references to object for low bound,
15046 high bound or count are not yet handled by this code. */
15047 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
15049 struct objfile
*objfile
= cu
->objfile
;
15050 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15051 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
15052 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
15054 /* Test "int", "long int", and "long long int" objfile types,
15055 and select the first one having a size above or equal to the
15056 architecture address size. */
15057 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15058 base_type
= int_type
;
15061 int_type
= objfile_type (objfile
)->builtin_long
;
15062 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15063 base_type
= int_type
;
15066 int_type
= objfile_type (objfile
)->builtin_long_long
;
15067 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15068 base_type
= int_type
;
15073 /* Normally, the DWARF producers are expected to use a signed
15074 constant form (Eg. DW_FORM_sdata) to express negative bounds.
15075 But this is unfortunately not always the case, as witnessed
15076 with GCC, for instance, where the ambiguous DW_FORM_dataN form
15077 is used instead. To work around that ambiguity, we treat
15078 the bounds as signed, and thus sign-extend their values, when
15079 the base type is signed. */
15081 -((LONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
15082 if (low
.kind
== PROP_CONST
15083 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
15084 low
.data
.const_val
|= negative_mask
;
15085 if (high
.kind
== PROP_CONST
15086 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
15087 high
.data
.const_val
|= negative_mask
;
15089 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
15091 if (high_bound_is_count
)
15092 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
15094 /* Ada expects an empty array on no boundary attributes. */
15095 if (attr
== NULL
&& cu
->language
!= language_ada
)
15096 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
15098 name
= dwarf2_name (die
, cu
);
15100 TYPE_NAME (range_type
) = name
;
15102 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15104 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
15106 set_die_type (die
, range_type
, cu
);
15108 /* set_die_type should be already done. */
15109 set_descriptive_type (range_type
, die
, cu
);
15114 static struct type
*
15115 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15119 /* For now, we only support the C meaning of an unspecified type: void. */
15121 type
= init_type (cu
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
15122 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
15124 return set_die_type (die
, type
, cu
);
15127 /* Read a single die and all its descendents. Set the die's sibling
15128 field to NULL; set other fields in the die correctly, and set all
15129 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
15130 location of the info_ptr after reading all of those dies. PARENT
15131 is the parent of the die in question. */
15133 static struct die_info
*
15134 read_die_and_children (const struct die_reader_specs
*reader
,
15135 const gdb_byte
*info_ptr
,
15136 const gdb_byte
**new_info_ptr
,
15137 struct die_info
*parent
)
15139 struct die_info
*die
;
15140 const gdb_byte
*cur_ptr
;
15143 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
15146 *new_info_ptr
= cur_ptr
;
15149 store_in_ref_table (die
, reader
->cu
);
15152 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
15156 *new_info_ptr
= cur_ptr
;
15159 die
->sibling
= NULL
;
15160 die
->parent
= parent
;
15164 /* Read a die, all of its descendents, and all of its siblings; set
15165 all of the fields of all of the dies correctly. Arguments are as
15166 in read_die_and_children. */
15168 static struct die_info
*
15169 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
15170 const gdb_byte
*info_ptr
,
15171 const gdb_byte
**new_info_ptr
,
15172 struct die_info
*parent
)
15174 struct die_info
*first_die
, *last_sibling
;
15175 const gdb_byte
*cur_ptr
;
15177 cur_ptr
= info_ptr
;
15178 first_die
= last_sibling
= NULL
;
15182 struct die_info
*die
15183 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
15187 *new_info_ptr
= cur_ptr
;
15194 last_sibling
->sibling
= die
;
15196 last_sibling
= die
;
15200 /* Read a die, all of its descendents, and all of its siblings; set
15201 all of the fields of all of the dies correctly. Arguments are as
15202 in read_die_and_children.
15203 This the main entry point for reading a DIE and all its children. */
15205 static struct die_info
*
15206 read_die_and_siblings (const struct die_reader_specs
*reader
,
15207 const gdb_byte
*info_ptr
,
15208 const gdb_byte
**new_info_ptr
,
15209 struct die_info
*parent
)
15211 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
15212 new_info_ptr
, parent
);
15214 if (dwarf_die_debug
)
15216 fprintf_unfiltered (gdb_stdlog
,
15217 "Read die from %s@0x%x of %s:\n",
15218 get_section_name (reader
->die_section
),
15219 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15220 bfd_get_filename (reader
->abfd
));
15221 dump_die (die
, dwarf_die_debug
);
15227 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
15229 The caller is responsible for filling in the extra attributes
15230 and updating (*DIEP)->num_attrs.
15231 Set DIEP to point to a newly allocated die with its information,
15232 except for its child, sibling, and parent fields.
15233 Set HAS_CHILDREN to tell whether the die has children or not. */
15235 static const gdb_byte
*
15236 read_full_die_1 (const struct die_reader_specs
*reader
,
15237 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15238 int *has_children
, int num_extra_attrs
)
15240 unsigned int abbrev_number
, bytes_read
, i
;
15241 sect_offset offset
;
15242 struct abbrev_info
*abbrev
;
15243 struct die_info
*die
;
15244 struct dwarf2_cu
*cu
= reader
->cu
;
15245 bfd
*abfd
= reader
->abfd
;
15247 offset
.sect_off
= info_ptr
- reader
->buffer
;
15248 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15249 info_ptr
+= bytes_read
;
15250 if (!abbrev_number
)
15257 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
15259 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
15261 bfd_get_filename (abfd
));
15263 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
15264 die
->offset
= offset
;
15265 die
->tag
= abbrev
->tag
;
15266 die
->abbrev
= abbrev_number
;
15268 /* Make the result usable.
15269 The caller needs to update num_attrs after adding the extra
15271 die
->num_attrs
= abbrev
->num_attrs
;
15273 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15274 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
15278 *has_children
= abbrev
->has_children
;
15282 /* Read a die and all its attributes.
15283 Set DIEP to point to a newly allocated die with its information,
15284 except for its child, sibling, and parent fields.
15285 Set HAS_CHILDREN to tell whether the die has children or not. */
15287 static const gdb_byte
*
15288 read_full_die (const struct die_reader_specs
*reader
,
15289 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15292 const gdb_byte
*result
;
15294 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
15296 if (dwarf_die_debug
)
15298 fprintf_unfiltered (gdb_stdlog
,
15299 "Read die from %s@0x%x of %s:\n",
15300 get_section_name (reader
->die_section
),
15301 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15302 bfd_get_filename (reader
->abfd
));
15303 dump_die (*diep
, dwarf_die_debug
);
15309 /* Abbreviation tables.
15311 In DWARF version 2, the description of the debugging information is
15312 stored in a separate .debug_abbrev section. Before we read any
15313 dies from a section we read in all abbreviations and install them
15314 in a hash table. */
15316 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
15318 static struct abbrev_info
*
15319 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
15321 struct abbrev_info
*abbrev
;
15323 abbrev
= XOBNEW (&abbrev_table
->abbrev_obstack
, struct abbrev_info
);
15324 memset (abbrev
, 0, sizeof (struct abbrev_info
));
15329 /* Add an abbreviation to the table. */
15332 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
15333 unsigned int abbrev_number
,
15334 struct abbrev_info
*abbrev
)
15336 unsigned int hash_number
;
15338 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15339 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
15340 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
15343 /* Look up an abbrev in the table.
15344 Returns NULL if the abbrev is not found. */
15346 static struct abbrev_info
*
15347 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
15348 unsigned int abbrev_number
)
15350 unsigned int hash_number
;
15351 struct abbrev_info
*abbrev
;
15353 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15354 abbrev
= abbrev_table
->abbrevs
[hash_number
];
15358 if (abbrev
->number
== abbrev_number
)
15360 abbrev
= abbrev
->next
;
15365 /* Read in an abbrev table. */
15367 static struct abbrev_table
*
15368 abbrev_table_read_table (struct dwarf2_section_info
*section
,
15369 sect_offset offset
)
15371 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15372 bfd
*abfd
= get_section_bfd_owner (section
);
15373 struct abbrev_table
*abbrev_table
;
15374 const gdb_byte
*abbrev_ptr
;
15375 struct abbrev_info
*cur_abbrev
;
15376 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
15377 unsigned int abbrev_form
;
15378 struct attr_abbrev
*cur_attrs
;
15379 unsigned int allocated_attrs
;
15381 abbrev_table
= XNEW (struct abbrev_table
);
15382 abbrev_table
->offset
= offset
;
15383 obstack_init (&abbrev_table
->abbrev_obstack
);
15384 abbrev_table
->abbrevs
=
15385 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct abbrev_info
*,
15387 memset (abbrev_table
->abbrevs
, 0,
15388 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
15390 dwarf2_read_section (objfile
, section
);
15391 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
15392 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15393 abbrev_ptr
+= bytes_read
;
15395 allocated_attrs
= ATTR_ALLOC_CHUNK
;
15396 cur_attrs
= XNEWVEC (struct attr_abbrev
, allocated_attrs
);
15398 /* Loop until we reach an abbrev number of 0. */
15399 while (abbrev_number
)
15401 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
15403 /* read in abbrev header */
15404 cur_abbrev
->number
= abbrev_number
;
15406 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15407 abbrev_ptr
+= bytes_read
;
15408 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
15411 /* now read in declarations */
15412 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15413 abbrev_ptr
+= bytes_read
;
15414 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15415 abbrev_ptr
+= bytes_read
;
15416 while (abbrev_name
)
15418 if (cur_abbrev
->num_attrs
== allocated_attrs
)
15420 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
15422 = XRESIZEVEC (struct attr_abbrev
, cur_attrs
, allocated_attrs
);
15425 cur_attrs
[cur_abbrev
->num_attrs
].name
15426 = (enum dwarf_attribute
) abbrev_name
;
15427 cur_attrs
[cur_abbrev
->num_attrs
++].form
15428 = (enum dwarf_form
) abbrev_form
;
15429 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15430 abbrev_ptr
+= bytes_read
;
15431 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15432 abbrev_ptr
+= bytes_read
;
15435 cur_abbrev
->attrs
=
15436 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct attr_abbrev
,
15437 cur_abbrev
->num_attrs
);
15438 memcpy (cur_abbrev
->attrs
, cur_attrs
,
15439 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
15441 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
15443 /* Get next abbreviation.
15444 Under Irix6 the abbreviations for a compilation unit are not
15445 always properly terminated with an abbrev number of 0.
15446 Exit loop if we encounter an abbreviation which we have
15447 already read (which means we are about to read the abbreviations
15448 for the next compile unit) or if the end of the abbreviation
15449 table is reached. */
15450 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
15452 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15453 abbrev_ptr
+= bytes_read
;
15454 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
15459 return abbrev_table
;
15462 /* Free the resources held by ABBREV_TABLE. */
15465 abbrev_table_free (struct abbrev_table
*abbrev_table
)
15467 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
15468 xfree (abbrev_table
);
15471 /* Same as abbrev_table_free but as a cleanup.
15472 We pass in a pointer to the pointer to the table so that we can
15473 set the pointer to NULL when we're done. It also simplifies
15474 build_type_psymtabs_1. */
15477 abbrev_table_free_cleanup (void *table_ptr
)
15479 struct abbrev_table
**abbrev_table_ptr
= (struct abbrev_table
**) table_ptr
;
15481 if (*abbrev_table_ptr
!= NULL
)
15482 abbrev_table_free (*abbrev_table_ptr
);
15483 *abbrev_table_ptr
= NULL
;
15486 /* Read the abbrev table for CU from ABBREV_SECTION. */
15489 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
15490 struct dwarf2_section_info
*abbrev_section
)
15493 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
15496 /* Release the memory used by the abbrev table for a compilation unit. */
15499 dwarf2_free_abbrev_table (void *ptr_to_cu
)
15501 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr_to_cu
;
15503 if (cu
->abbrev_table
!= NULL
)
15504 abbrev_table_free (cu
->abbrev_table
);
15505 /* Set this to NULL so that we SEGV if we try to read it later,
15506 and also because free_comp_unit verifies this is NULL. */
15507 cu
->abbrev_table
= NULL
;
15510 /* Returns nonzero if TAG represents a type that we might generate a partial
15514 is_type_tag_for_partial (int tag
)
15519 /* Some types that would be reasonable to generate partial symbols for,
15520 that we don't at present. */
15521 case DW_TAG_array_type
:
15522 case DW_TAG_file_type
:
15523 case DW_TAG_ptr_to_member_type
:
15524 case DW_TAG_set_type
:
15525 case DW_TAG_string_type
:
15526 case DW_TAG_subroutine_type
:
15528 case DW_TAG_base_type
:
15529 case DW_TAG_class_type
:
15530 case DW_TAG_interface_type
:
15531 case DW_TAG_enumeration_type
:
15532 case DW_TAG_structure_type
:
15533 case DW_TAG_subrange_type
:
15534 case DW_TAG_typedef
:
15535 case DW_TAG_union_type
:
15542 /* Load all DIEs that are interesting for partial symbols into memory. */
15544 static struct partial_die_info
*
15545 load_partial_dies (const struct die_reader_specs
*reader
,
15546 const gdb_byte
*info_ptr
, int building_psymtab
)
15548 struct dwarf2_cu
*cu
= reader
->cu
;
15549 struct objfile
*objfile
= cu
->objfile
;
15550 struct partial_die_info
*part_die
;
15551 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
15552 struct abbrev_info
*abbrev
;
15553 unsigned int bytes_read
;
15554 unsigned int load_all
= 0;
15555 int nesting_level
= 1;
15560 gdb_assert (cu
->per_cu
!= NULL
);
15561 if (cu
->per_cu
->load_all_dies
)
15565 = htab_create_alloc_ex (cu
->header
.length
/ 12,
15569 &cu
->comp_unit_obstack
,
15570 hashtab_obstack_allocate
,
15571 dummy_obstack_deallocate
);
15573 part_die
= XOBNEW (&cu
->comp_unit_obstack
, struct partial_die_info
);
15577 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
15579 /* A NULL abbrev means the end of a series of children. */
15580 if (abbrev
== NULL
)
15582 if (--nesting_level
== 0)
15584 /* PART_DIE was probably the last thing allocated on the
15585 comp_unit_obstack, so we could call obstack_free
15586 here. We don't do that because the waste is small,
15587 and will be cleaned up when we're done with this
15588 compilation unit. This way, we're also more robust
15589 against other users of the comp_unit_obstack. */
15592 info_ptr
+= bytes_read
;
15593 last_die
= parent_die
;
15594 parent_die
= parent_die
->die_parent
;
15598 /* Check for template arguments. We never save these; if
15599 they're seen, we just mark the parent, and go on our way. */
15600 if (parent_die
!= NULL
15601 && cu
->language
== language_cplus
15602 && (abbrev
->tag
== DW_TAG_template_type_param
15603 || abbrev
->tag
== DW_TAG_template_value_param
))
15605 parent_die
->has_template_arguments
= 1;
15609 /* We don't need a partial DIE for the template argument. */
15610 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15615 /* We only recurse into c++ subprograms looking for template arguments.
15616 Skip their other children. */
15618 && cu
->language
== language_cplus
15619 && parent_die
!= NULL
15620 && parent_die
->tag
== DW_TAG_subprogram
)
15622 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15626 /* Check whether this DIE is interesting enough to save. Normally
15627 we would not be interested in members here, but there may be
15628 later variables referencing them via DW_AT_specification (for
15629 static members). */
15631 && !is_type_tag_for_partial (abbrev
->tag
)
15632 && abbrev
->tag
!= DW_TAG_constant
15633 && abbrev
->tag
!= DW_TAG_enumerator
15634 && abbrev
->tag
!= DW_TAG_subprogram
15635 && abbrev
->tag
!= DW_TAG_lexical_block
15636 && abbrev
->tag
!= DW_TAG_variable
15637 && abbrev
->tag
!= DW_TAG_namespace
15638 && abbrev
->tag
!= DW_TAG_module
15639 && abbrev
->tag
!= DW_TAG_member
15640 && abbrev
->tag
!= DW_TAG_imported_unit
15641 && abbrev
->tag
!= DW_TAG_imported_declaration
)
15643 /* Otherwise we skip to the next sibling, if any. */
15644 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15648 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
15651 /* This two-pass algorithm for processing partial symbols has a
15652 high cost in cache pressure. Thus, handle some simple cases
15653 here which cover the majority of C partial symbols. DIEs
15654 which neither have specification tags in them, nor could have
15655 specification tags elsewhere pointing at them, can simply be
15656 processed and discarded.
15658 This segment is also optional; scan_partial_symbols and
15659 add_partial_symbol will handle these DIEs if we chain
15660 them in normally. When compilers which do not emit large
15661 quantities of duplicate debug information are more common,
15662 this code can probably be removed. */
15664 /* Any complete simple types at the top level (pretty much all
15665 of them, for a language without namespaces), can be processed
15667 if (parent_die
== NULL
15668 && part_die
->has_specification
== 0
15669 && part_die
->is_declaration
== 0
15670 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
15671 || part_die
->tag
== DW_TAG_base_type
15672 || part_die
->tag
== DW_TAG_subrange_type
))
15674 if (building_psymtab
&& part_die
->name
!= NULL
)
15675 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15676 VAR_DOMAIN
, LOC_TYPEDEF
,
15677 &objfile
->static_psymbols
,
15678 0, cu
->language
, objfile
);
15679 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15683 /* The exception for DW_TAG_typedef with has_children above is
15684 a workaround of GCC PR debug/47510. In the case of this complaint
15685 type_name_no_tag_or_error will error on such types later.
15687 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15688 it could not find the child DIEs referenced later, this is checked
15689 above. In correct DWARF DW_TAG_typedef should have no children. */
15691 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
15692 complaint (&symfile_complaints
,
15693 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15694 "- DIE at 0x%x [in module %s]"),
15695 part_die
->offset
.sect_off
, objfile_name (objfile
));
15697 /* If we're at the second level, and we're an enumerator, and
15698 our parent has no specification (meaning possibly lives in a
15699 namespace elsewhere), then we can add the partial symbol now
15700 instead of queueing it. */
15701 if (part_die
->tag
== DW_TAG_enumerator
15702 && parent_die
!= NULL
15703 && parent_die
->die_parent
== NULL
15704 && parent_die
->tag
== DW_TAG_enumeration_type
15705 && parent_die
->has_specification
== 0)
15707 if (part_die
->name
== NULL
)
15708 complaint (&symfile_complaints
,
15709 _("malformed enumerator DIE ignored"));
15710 else if (building_psymtab
)
15711 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15712 VAR_DOMAIN
, LOC_CONST
,
15713 cu
->language
== language_cplus
15714 ? &objfile
->global_psymbols
15715 : &objfile
->static_psymbols
,
15716 0, cu
->language
, objfile
);
15718 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15722 /* We'll save this DIE so link it in. */
15723 part_die
->die_parent
= parent_die
;
15724 part_die
->die_sibling
= NULL
;
15725 part_die
->die_child
= NULL
;
15727 if (last_die
&& last_die
== parent_die
)
15728 last_die
->die_child
= part_die
;
15730 last_die
->die_sibling
= part_die
;
15732 last_die
= part_die
;
15734 if (first_die
== NULL
)
15735 first_die
= part_die
;
15737 /* Maybe add the DIE to the hash table. Not all DIEs that we
15738 find interesting need to be in the hash table, because we
15739 also have the parent/sibling/child chains; only those that we
15740 might refer to by offset later during partial symbol reading.
15742 For now this means things that might have be the target of a
15743 DW_AT_specification, DW_AT_abstract_origin, or
15744 DW_AT_extension. DW_AT_extension will refer only to
15745 namespaces; DW_AT_abstract_origin refers to functions (and
15746 many things under the function DIE, but we do not recurse
15747 into function DIEs during partial symbol reading) and
15748 possibly variables as well; DW_AT_specification refers to
15749 declarations. Declarations ought to have the DW_AT_declaration
15750 flag. It happens that GCC forgets to put it in sometimes, but
15751 only for functions, not for types.
15753 Adding more things than necessary to the hash table is harmless
15754 except for the performance cost. Adding too few will result in
15755 wasted time in find_partial_die, when we reread the compilation
15756 unit with load_all_dies set. */
15759 || abbrev
->tag
== DW_TAG_constant
15760 || abbrev
->tag
== DW_TAG_subprogram
15761 || abbrev
->tag
== DW_TAG_variable
15762 || abbrev
->tag
== DW_TAG_namespace
15763 || part_die
->is_declaration
)
15767 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
15768 part_die
->offset
.sect_off
, INSERT
);
15772 part_die
= XOBNEW (&cu
->comp_unit_obstack
, struct partial_die_info
);
15774 /* For some DIEs we want to follow their children (if any). For C
15775 we have no reason to follow the children of structures; for other
15776 languages we have to, so that we can get at method physnames
15777 to infer fully qualified class names, for DW_AT_specification,
15778 and for C++ template arguments. For C++, we also look one level
15779 inside functions to find template arguments (if the name of the
15780 function does not already contain the template arguments).
15782 For Ada, we need to scan the children of subprograms and lexical
15783 blocks as well because Ada allows the definition of nested
15784 entities that could be interesting for the debugger, such as
15785 nested subprograms for instance. */
15786 if (last_die
->has_children
15788 || last_die
->tag
== DW_TAG_namespace
15789 || last_die
->tag
== DW_TAG_module
15790 || last_die
->tag
== DW_TAG_enumeration_type
15791 || (cu
->language
== language_cplus
15792 && last_die
->tag
== DW_TAG_subprogram
15793 && (last_die
->name
== NULL
15794 || strchr (last_die
->name
, '<') == NULL
))
15795 || (cu
->language
!= language_c
15796 && (last_die
->tag
== DW_TAG_class_type
15797 || last_die
->tag
== DW_TAG_interface_type
15798 || last_die
->tag
== DW_TAG_structure_type
15799 || last_die
->tag
== DW_TAG_union_type
))
15800 || (cu
->language
== language_ada
15801 && (last_die
->tag
== DW_TAG_subprogram
15802 || last_die
->tag
== DW_TAG_lexical_block
))))
15805 parent_die
= last_die
;
15809 /* Otherwise we skip to the next sibling, if any. */
15810 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
15812 /* Back to the top, do it again. */
15816 /* Read a minimal amount of information into the minimal die structure. */
15818 static const gdb_byte
*
15819 read_partial_die (const struct die_reader_specs
*reader
,
15820 struct partial_die_info
*part_die
,
15821 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
15822 const gdb_byte
*info_ptr
)
15824 struct dwarf2_cu
*cu
= reader
->cu
;
15825 struct objfile
*objfile
= cu
->objfile
;
15826 const gdb_byte
*buffer
= reader
->buffer
;
15828 struct attribute attr
;
15829 int has_low_pc_attr
= 0;
15830 int has_high_pc_attr
= 0;
15831 int high_pc_relative
= 0;
15833 memset (part_die
, 0, sizeof (struct partial_die_info
));
15835 part_die
->offset
.sect_off
= info_ptr
- buffer
;
15837 info_ptr
+= abbrev_len
;
15839 if (abbrev
== NULL
)
15842 part_die
->tag
= abbrev
->tag
;
15843 part_die
->has_children
= abbrev
->has_children
;
15845 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15847 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
15849 /* Store the data if it is of an attribute we want to keep in a
15850 partial symbol table. */
15854 switch (part_die
->tag
)
15856 case DW_TAG_compile_unit
:
15857 case DW_TAG_partial_unit
:
15858 case DW_TAG_type_unit
:
15859 /* Compilation units have a DW_AT_name that is a filename, not
15860 a source language identifier. */
15861 case DW_TAG_enumeration_type
:
15862 case DW_TAG_enumerator
:
15863 /* These tags always have simple identifiers already; no need
15864 to canonicalize them. */
15865 part_die
->name
= DW_STRING (&attr
);
15869 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
15870 &objfile
->per_bfd
->storage_obstack
);
15874 case DW_AT_linkage_name
:
15875 case DW_AT_MIPS_linkage_name
:
15876 /* Note that both forms of linkage name might appear. We
15877 assume they will be the same, and we only store the last
15879 if (cu
->language
== language_ada
)
15880 part_die
->name
= DW_STRING (&attr
);
15881 part_die
->linkage_name
= DW_STRING (&attr
);
15884 has_low_pc_attr
= 1;
15885 part_die
->lowpc
= attr_value_as_address (&attr
);
15887 case DW_AT_high_pc
:
15888 has_high_pc_attr
= 1;
15889 part_die
->highpc
= attr_value_as_address (&attr
);
15890 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
15891 high_pc_relative
= 1;
15893 case DW_AT_location
:
15894 /* Support the .debug_loc offsets. */
15895 if (attr_form_is_block (&attr
))
15897 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
15899 else if (attr_form_is_section_offset (&attr
))
15901 dwarf2_complex_location_expr_complaint ();
15905 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15906 "partial symbol information");
15909 case DW_AT_external
:
15910 part_die
->is_external
= DW_UNSND (&attr
);
15912 case DW_AT_declaration
:
15913 part_die
->is_declaration
= DW_UNSND (&attr
);
15916 part_die
->has_type
= 1;
15918 case DW_AT_abstract_origin
:
15919 case DW_AT_specification
:
15920 case DW_AT_extension
:
15921 part_die
->has_specification
= 1;
15922 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
15923 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15924 || cu
->per_cu
->is_dwz
);
15926 case DW_AT_sibling
:
15927 /* Ignore absolute siblings, they might point outside of
15928 the current compile unit. */
15929 if (attr
.form
== DW_FORM_ref_addr
)
15930 complaint (&symfile_complaints
,
15931 _("ignoring absolute DW_AT_sibling"));
15934 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
15935 const gdb_byte
*sibling_ptr
= buffer
+ off
;
15937 if (sibling_ptr
< info_ptr
)
15938 complaint (&symfile_complaints
,
15939 _("DW_AT_sibling points backwards"));
15940 else if (sibling_ptr
> reader
->buffer_end
)
15941 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
15943 part_die
->sibling
= sibling_ptr
;
15946 case DW_AT_byte_size
:
15947 part_die
->has_byte_size
= 1;
15949 case DW_AT_const_value
:
15950 part_die
->has_const_value
= 1;
15952 case DW_AT_calling_convention
:
15953 /* DWARF doesn't provide a way to identify a program's source-level
15954 entry point. DW_AT_calling_convention attributes are only meant
15955 to describe functions' calling conventions.
15957 However, because it's a necessary piece of information in
15958 Fortran, and before DWARF 4 DW_CC_program was the only
15959 piece of debugging information whose definition refers to
15960 a 'main program' at all, several compilers marked Fortran
15961 main programs with DW_CC_program --- even when those
15962 functions use the standard calling conventions.
15964 Although DWARF now specifies a way to provide this
15965 information, we support this practice for backward
15967 if (DW_UNSND (&attr
) == DW_CC_program
15968 && cu
->language
== language_fortran
)
15969 part_die
->main_subprogram
= 1;
15972 if (DW_UNSND (&attr
) == DW_INL_inlined
15973 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
15974 part_die
->may_be_inlined
= 1;
15978 if (part_die
->tag
== DW_TAG_imported_unit
)
15980 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
15981 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15982 || cu
->per_cu
->is_dwz
);
15986 case DW_AT_main_subprogram
:
15987 part_die
->main_subprogram
= DW_UNSND (&attr
);
15995 if (high_pc_relative
)
15996 part_die
->highpc
+= part_die
->lowpc
;
15998 if (has_low_pc_attr
&& has_high_pc_attr
)
16000 /* When using the GNU linker, .gnu.linkonce. sections are used to
16001 eliminate duplicate copies of functions and vtables and such.
16002 The linker will arbitrarily choose one and discard the others.
16003 The AT_*_pc values for such functions refer to local labels in
16004 these sections. If the section from that file was discarded, the
16005 labels are not in the output, so the relocs get a value of 0.
16006 If this is a discarded function, mark the pc bounds as invalid,
16007 so that GDB will ignore it. */
16008 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
16010 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16012 complaint (&symfile_complaints
,
16013 _("DW_AT_low_pc %s is zero "
16014 "for DIE at 0x%x [in module %s]"),
16015 paddress (gdbarch
, part_die
->lowpc
),
16016 part_die
->offset
.sect_off
, objfile_name (objfile
));
16018 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
16019 else if (part_die
->lowpc
>= part_die
->highpc
)
16021 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16023 complaint (&symfile_complaints
,
16024 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
16025 "for DIE at 0x%x [in module %s]"),
16026 paddress (gdbarch
, part_die
->lowpc
),
16027 paddress (gdbarch
, part_die
->highpc
),
16028 part_die
->offset
.sect_off
, objfile_name (objfile
));
16031 part_die
->has_pc_info
= 1;
16037 /* Find a cached partial DIE at OFFSET in CU. */
16039 static struct partial_die_info
*
16040 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
16042 struct partial_die_info
*lookup_die
= NULL
;
16043 struct partial_die_info part_die
;
16045 part_die
.offset
= offset
;
16046 lookup_die
= ((struct partial_die_info
*)
16047 htab_find_with_hash (cu
->partial_dies
, &part_die
,
16053 /* Find a partial DIE at OFFSET, which may or may not be in CU,
16054 except in the case of .debug_types DIEs which do not reference
16055 outside their CU (they do however referencing other types via
16056 DW_FORM_ref_sig8). */
16058 static struct partial_die_info
*
16059 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
16061 struct objfile
*objfile
= cu
->objfile
;
16062 struct dwarf2_per_cu_data
*per_cu
= NULL
;
16063 struct partial_die_info
*pd
= NULL
;
16065 if (offset_in_dwz
== cu
->per_cu
->is_dwz
16066 && offset_in_cu_p (&cu
->header
, offset
))
16068 pd
= find_partial_die_in_comp_unit (offset
, cu
);
16071 /* We missed recording what we needed.
16072 Load all dies and try again. */
16073 per_cu
= cu
->per_cu
;
16077 /* TUs don't reference other CUs/TUs (except via type signatures). */
16078 if (cu
->per_cu
->is_debug_types
)
16080 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
16081 " external reference to offset 0x%lx [in module %s].\n"),
16082 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
16083 bfd_get_filename (objfile
->obfd
));
16085 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
16088 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
16089 load_partial_comp_unit (per_cu
);
16091 per_cu
->cu
->last_used
= 0;
16092 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16095 /* If we didn't find it, and not all dies have been loaded,
16096 load them all and try again. */
16098 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
16100 per_cu
->load_all_dies
= 1;
16102 /* This is nasty. When we reread the DIEs, somewhere up the call chain
16103 THIS_CU->cu may already be in use. So we can't just free it and
16104 replace its DIEs with the ones we read in. Instead, we leave those
16105 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
16106 and clobber THIS_CU->cu->partial_dies with the hash table for the new
16108 load_partial_comp_unit (per_cu
);
16110 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16114 internal_error (__FILE__
, __LINE__
,
16115 _("could not find partial DIE 0x%x "
16116 "in cache [from module %s]\n"),
16117 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
16121 /* See if we can figure out if the class lives in a namespace. We do
16122 this by looking for a member function; its demangled name will
16123 contain namespace info, if there is any. */
16126 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
16127 struct dwarf2_cu
*cu
)
16129 /* NOTE: carlton/2003-10-07: Getting the info this way changes
16130 what template types look like, because the demangler
16131 frequently doesn't give the same name as the debug info. We
16132 could fix this by only using the demangled name to get the
16133 prefix (but see comment in read_structure_type). */
16135 struct partial_die_info
*real_pdi
;
16136 struct partial_die_info
*child_pdi
;
16138 /* If this DIE (this DIE's specification, if any) has a parent, then
16139 we should not do this. We'll prepend the parent's fully qualified
16140 name when we create the partial symbol. */
16142 real_pdi
= struct_pdi
;
16143 while (real_pdi
->has_specification
)
16144 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
16145 real_pdi
->spec_is_dwz
, cu
);
16147 if (real_pdi
->die_parent
!= NULL
)
16150 for (child_pdi
= struct_pdi
->die_child
;
16152 child_pdi
= child_pdi
->die_sibling
)
16154 if (child_pdi
->tag
== DW_TAG_subprogram
16155 && child_pdi
->linkage_name
!= NULL
)
16157 char *actual_class_name
16158 = language_class_name_from_physname (cu
->language_defn
,
16159 child_pdi
->linkage_name
);
16160 if (actual_class_name
!= NULL
)
16164 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16166 strlen (actual_class_name
)));
16167 xfree (actual_class_name
);
16174 /* Adjust PART_DIE before generating a symbol for it. This function
16175 may set the is_external flag or change the DIE's name. */
16178 fixup_partial_die (struct partial_die_info
*part_die
,
16179 struct dwarf2_cu
*cu
)
16181 /* Once we've fixed up a die, there's no point in doing so again.
16182 This also avoids a memory leak if we were to call
16183 guess_partial_die_structure_name multiple times. */
16184 if (part_die
->fixup_called
)
16187 /* If we found a reference attribute and the DIE has no name, try
16188 to find a name in the referred to DIE. */
16190 if (part_die
->name
== NULL
&& part_die
->has_specification
)
16192 struct partial_die_info
*spec_die
;
16194 spec_die
= find_partial_die (part_die
->spec_offset
,
16195 part_die
->spec_is_dwz
, cu
);
16197 fixup_partial_die (spec_die
, cu
);
16199 if (spec_die
->name
)
16201 part_die
->name
= spec_die
->name
;
16203 /* Copy DW_AT_external attribute if it is set. */
16204 if (spec_die
->is_external
)
16205 part_die
->is_external
= spec_die
->is_external
;
16209 /* Set default names for some unnamed DIEs. */
16211 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
16212 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
16214 /* If there is no parent die to provide a namespace, and there are
16215 children, see if we can determine the namespace from their linkage
16217 if (cu
->language
== language_cplus
16218 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
16219 && part_die
->die_parent
== NULL
16220 && part_die
->has_children
16221 && (part_die
->tag
== DW_TAG_class_type
16222 || part_die
->tag
== DW_TAG_structure_type
16223 || part_die
->tag
== DW_TAG_union_type
))
16224 guess_partial_die_structure_name (part_die
, cu
);
16226 /* GCC might emit a nameless struct or union that has a linkage
16227 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16228 if (part_die
->name
== NULL
16229 && (part_die
->tag
== DW_TAG_class_type
16230 || part_die
->tag
== DW_TAG_interface_type
16231 || part_die
->tag
== DW_TAG_structure_type
16232 || part_die
->tag
== DW_TAG_union_type
)
16233 && part_die
->linkage_name
!= NULL
)
16237 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
16242 /* Strip any leading namespaces/classes, keep only the base name.
16243 DW_AT_name for named DIEs does not contain the prefixes. */
16244 base
= strrchr (demangled
, ':');
16245 if (base
&& base
> demangled
&& base
[-1] == ':')
16252 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16253 base
, strlen (base
)));
16258 part_die
->fixup_called
= 1;
16261 /* Read an attribute value described by an attribute form. */
16263 static const gdb_byte
*
16264 read_attribute_value (const struct die_reader_specs
*reader
,
16265 struct attribute
*attr
, unsigned form
,
16266 const gdb_byte
*info_ptr
)
16268 struct dwarf2_cu
*cu
= reader
->cu
;
16269 struct objfile
*objfile
= cu
->objfile
;
16270 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16271 bfd
*abfd
= reader
->abfd
;
16272 struct comp_unit_head
*cu_header
= &cu
->header
;
16273 unsigned int bytes_read
;
16274 struct dwarf_block
*blk
;
16276 attr
->form
= (enum dwarf_form
) form
;
16279 case DW_FORM_ref_addr
:
16280 if (cu
->header
.version
== 2)
16281 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16283 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
16284 &cu
->header
, &bytes_read
);
16285 info_ptr
+= bytes_read
;
16287 case DW_FORM_GNU_ref_alt
:
16288 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16289 info_ptr
+= bytes_read
;
16292 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16293 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
16294 info_ptr
+= bytes_read
;
16296 case DW_FORM_block2
:
16297 blk
= dwarf_alloc_block (cu
);
16298 blk
->size
= read_2_bytes (abfd
, info_ptr
);
16300 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16301 info_ptr
+= blk
->size
;
16302 DW_BLOCK (attr
) = blk
;
16304 case DW_FORM_block4
:
16305 blk
= dwarf_alloc_block (cu
);
16306 blk
->size
= read_4_bytes (abfd
, info_ptr
);
16308 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16309 info_ptr
+= blk
->size
;
16310 DW_BLOCK (attr
) = blk
;
16312 case DW_FORM_data2
:
16313 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
16316 case DW_FORM_data4
:
16317 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
16320 case DW_FORM_data8
:
16321 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
16324 case DW_FORM_sec_offset
:
16325 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16326 info_ptr
+= bytes_read
;
16328 case DW_FORM_string
:
16329 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
16330 DW_STRING_IS_CANONICAL (attr
) = 0;
16331 info_ptr
+= bytes_read
;
16334 if (!cu
->per_cu
->is_dwz
)
16336 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
16338 DW_STRING_IS_CANONICAL (attr
) = 0;
16339 info_ptr
+= bytes_read
;
16343 case DW_FORM_GNU_strp_alt
:
16345 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
16346 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
16349 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
16350 DW_STRING_IS_CANONICAL (attr
) = 0;
16351 info_ptr
+= bytes_read
;
16354 case DW_FORM_exprloc
:
16355 case DW_FORM_block
:
16356 blk
= dwarf_alloc_block (cu
);
16357 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16358 info_ptr
+= bytes_read
;
16359 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16360 info_ptr
+= blk
->size
;
16361 DW_BLOCK (attr
) = blk
;
16363 case DW_FORM_block1
:
16364 blk
= dwarf_alloc_block (cu
);
16365 blk
->size
= read_1_byte (abfd
, info_ptr
);
16367 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16368 info_ptr
+= blk
->size
;
16369 DW_BLOCK (attr
) = blk
;
16371 case DW_FORM_data1
:
16372 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16376 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16379 case DW_FORM_flag_present
:
16380 DW_UNSND (attr
) = 1;
16382 case DW_FORM_sdata
:
16383 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
16384 info_ptr
+= bytes_read
;
16386 case DW_FORM_udata
:
16387 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16388 info_ptr
+= bytes_read
;
16391 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16392 + read_1_byte (abfd
, info_ptr
));
16396 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16397 + read_2_bytes (abfd
, info_ptr
));
16401 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16402 + read_4_bytes (abfd
, info_ptr
));
16406 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16407 + read_8_bytes (abfd
, info_ptr
));
16410 case DW_FORM_ref_sig8
:
16411 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
16414 case DW_FORM_ref_udata
:
16415 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16416 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
16417 info_ptr
+= bytes_read
;
16419 case DW_FORM_indirect
:
16420 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16421 info_ptr
+= bytes_read
;
16422 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
16424 case DW_FORM_GNU_addr_index
:
16425 if (reader
->dwo_file
== NULL
)
16427 /* For now flag a hard error.
16428 Later we can turn this into a complaint. */
16429 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16430 dwarf_form_name (form
),
16431 bfd_get_filename (abfd
));
16433 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
16434 info_ptr
+= bytes_read
;
16436 case DW_FORM_GNU_str_index
:
16437 if (reader
->dwo_file
== NULL
)
16439 /* For now flag a hard error.
16440 Later we can turn this into a complaint if warranted. */
16441 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16442 dwarf_form_name (form
),
16443 bfd_get_filename (abfd
));
16446 ULONGEST str_index
=
16447 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16449 DW_STRING (attr
) = read_str_index (reader
, str_index
);
16450 DW_STRING_IS_CANONICAL (attr
) = 0;
16451 info_ptr
+= bytes_read
;
16455 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16456 dwarf_form_name (form
),
16457 bfd_get_filename (abfd
));
16461 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
16462 attr
->form
= DW_FORM_GNU_ref_alt
;
16464 /* We have seen instances where the compiler tried to emit a byte
16465 size attribute of -1 which ended up being encoded as an unsigned
16466 0xffffffff. Although 0xffffffff is technically a valid size value,
16467 an object of this size seems pretty unlikely so we can relatively
16468 safely treat these cases as if the size attribute was invalid and
16469 treat them as zero by default. */
16470 if (attr
->name
== DW_AT_byte_size
16471 && form
== DW_FORM_data4
16472 && DW_UNSND (attr
) >= 0xffffffff)
16475 (&symfile_complaints
,
16476 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16477 hex_string (DW_UNSND (attr
)));
16478 DW_UNSND (attr
) = 0;
16484 /* Read an attribute described by an abbreviated attribute. */
16486 static const gdb_byte
*
16487 read_attribute (const struct die_reader_specs
*reader
,
16488 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
16489 const gdb_byte
*info_ptr
)
16491 attr
->name
= abbrev
->name
;
16492 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
16495 /* Read dwarf information from a buffer. */
16497 static unsigned int
16498 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
16500 return bfd_get_8 (abfd
, buf
);
16504 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
16506 return bfd_get_signed_8 (abfd
, buf
);
16509 static unsigned int
16510 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16512 return bfd_get_16 (abfd
, buf
);
16516 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16518 return bfd_get_signed_16 (abfd
, buf
);
16521 static unsigned int
16522 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16524 return bfd_get_32 (abfd
, buf
);
16528 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16530 return bfd_get_signed_32 (abfd
, buf
);
16534 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16536 return bfd_get_64 (abfd
, buf
);
16540 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
16541 unsigned int *bytes_read
)
16543 struct comp_unit_head
*cu_header
= &cu
->header
;
16544 CORE_ADDR retval
= 0;
16546 if (cu_header
->signed_addr_p
)
16548 switch (cu_header
->addr_size
)
16551 retval
= bfd_get_signed_16 (abfd
, buf
);
16554 retval
= bfd_get_signed_32 (abfd
, buf
);
16557 retval
= bfd_get_signed_64 (abfd
, buf
);
16560 internal_error (__FILE__
, __LINE__
,
16561 _("read_address: bad switch, signed [in module %s]"),
16562 bfd_get_filename (abfd
));
16567 switch (cu_header
->addr_size
)
16570 retval
= bfd_get_16 (abfd
, buf
);
16573 retval
= bfd_get_32 (abfd
, buf
);
16576 retval
= bfd_get_64 (abfd
, buf
);
16579 internal_error (__FILE__
, __LINE__
,
16580 _("read_address: bad switch, "
16581 "unsigned [in module %s]"),
16582 bfd_get_filename (abfd
));
16586 *bytes_read
= cu_header
->addr_size
;
16590 /* Read the initial length from a section. The (draft) DWARF 3
16591 specification allows the initial length to take up either 4 bytes
16592 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16593 bytes describe the length and all offsets will be 8 bytes in length
16596 An older, non-standard 64-bit format is also handled by this
16597 function. The older format in question stores the initial length
16598 as an 8-byte quantity without an escape value. Lengths greater
16599 than 2^32 aren't very common which means that the initial 4 bytes
16600 is almost always zero. Since a length value of zero doesn't make
16601 sense for the 32-bit format, this initial zero can be considered to
16602 be an escape value which indicates the presence of the older 64-bit
16603 format. As written, the code can't detect (old format) lengths
16604 greater than 4GB. If it becomes necessary to handle lengths
16605 somewhat larger than 4GB, we could allow other small values (such
16606 as the non-sensical values of 1, 2, and 3) to also be used as
16607 escape values indicating the presence of the old format.
16609 The value returned via bytes_read should be used to increment the
16610 relevant pointer after calling read_initial_length().
16612 [ Note: read_initial_length() and read_offset() are based on the
16613 document entitled "DWARF Debugging Information Format", revision
16614 3, draft 8, dated November 19, 2001. This document was obtained
16617 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16619 This document is only a draft and is subject to change. (So beware.)
16621 Details regarding the older, non-standard 64-bit format were
16622 determined empirically by examining 64-bit ELF files produced by
16623 the SGI toolchain on an IRIX 6.5 machine.
16625 - Kevin, July 16, 2002
16629 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
16631 LONGEST length
= bfd_get_32 (abfd
, buf
);
16633 if (length
== 0xffffffff)
16635 length
= bfd_get_64 (abfd
, buf
+ 4);
16638 else if (length
== 0)
16640 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16641 length
= bfd_get_64 (abfd
, buf
);
16652 /* Cover function for read_initial_length.
16653 Returns the length of the object at BUF, and stores the size of the
16654 initial length in *BYTES_READ and stores the size that offsets will be in
16656 If the initial length size is not equivalent to that specified in
16657 CU_HEADER then issue a complaint.
16658 This is useful when reading non-comp-unit headers. */
16661 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
16662 const struct comp_unit_head
*cu_header
,
16663 unsigned int *bytes_read
,
16664 unsigned int *offset_size
)
16666 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
16668 gdb_assert (cu_header
->initial_length_size
== 4
16669 || cu_header
->initial_length_size
== 8
16670 || cu_header
->initial_length_size
== 12);
16672 if (cu_header
->initial_length_size
!= *bytes_read
)
16673 complaint (&symfile_complaints
,
16674 _("intermixed 32-bit and 64-bit DWARF sections"));
16676 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
16680 /* Read an offset from the data stream. The size of the offset is
16681 given by cu_header->offset_size. */
16684 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
16685 const struct comp_unit_head
*cu_header
,
16686 unsigned int *bytes_read
)
16688 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
16690 *bytes_read
= cu_header
->offset_size
;
16694 /* Read an offset from the data stream. */
16697 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
16699 LONGEST retval
= 0;
16701 switch (offset_size
)
16704 retval
= bfd_get_32 (abfd
, buf
);
16707 retval
= bfd_get_64 (abfd
, buf
);
16710 internal_error (__FILE__
, __LINE__
,
16711 _("read_offset_1: bad switch [in module %s]"),
16712 bfd_get_filename (abfd
));
16718 static const gdb_byte
*
16719 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
16721 /* If the size of a host char is 8 bits, we can return a pointer
16722 to the buffer, otherwise we have to copy the data to a buffer
16723 allocated on the temporary obstack. */
16724 gdb_assert (HOST_CHAR_BIT
== 8);
16728 static const char *
16729 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
16730 unsigned int *bytes_read_ptr
)
16732 /* If the size of a host char is 8 bits, we can return a pointer
16733 to the string, otherwise we have to copy the string to a buffer
16734 allocated on the temporary obstack. */
16735 gdb_assert (HOST_CHAR_BIT
== 8);
16738 *bytes_read_ptr
= 1;
16741 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
16742 return (const char *) buf
;
16745 static const char *
16746 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
16748 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
16749 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
16750 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16751 bfd_get_filename (abfd
));
16752 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
16753 error (_("DW_FORM_strp pointing outside of "
16754 ".debug_str section [in module %s]"),
16755 bfd_get_filename (abfd
));
16756 gdb_assert (HOST_CHAR_BIT
== 8);
16757 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
16759 return (const char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
16762 /* Read a string at offset STR_OFFSET in the .debug_str section from
16763 the .dwz file DWZ. Throw an error if the offset is too large. If
16764 the string consists of a single NUL byte, return NULL; otherwise
16765 return a pointer to the string. */
16767 static const char *
16768 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
16770 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
16772 if (dwz
->str
.buffer
== NULL
)
16773 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16774 "section [in module %s]"),
16775 bfd_get_filename (dwz
->dwz_bfd
));
16776 if (str_offset
>= dwz
->str
.size
)
16777 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16778 ".debug_str section [in module %s]"),
16779 bfd_get_filename (dwz
->dwz_bfd
));
16780 gdb_assert (HOST_CHAR_BIT
== 8);
16781 if (dwz
->str
.buffer
[str_offset
] == '\0')
16783 return (const char *) (dwz
->str
.buffer
+ str_offset
);
16786 static const char *
16787 read_indirect_string (bfd
*abfd
, const gdb_byte
*buf
,
16788 const struct comp_unit_head
*cu_header
,
16789 unsigned int *bytes_read_ptr
)
16791 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
16793 return read_indirect_string_at_offset (abfd
, str_offset
);
16797 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16798 unsigned int *bytes_read_ptr
)
16801 unsigned int num_read
;
16803 unsigned char byte
;
16810 byte
= bfd_get_8 (abfd
, buf
);
16813 result
|= ((ULONGEST
) (byte
& 127) << shift
);
16814 if ((byte
& 128) == 0)
16820 *bytes_read_ptr
= num_read
;
16825 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16826 unsigned int *bytes_read_ptr
)
16829 int shift
, num_read
;
16830 unsigned char byte
;
16837 byte
= bfd_get_8 (abfd
, buf
);
16840 result
|= ((LONGEST
) (byte
& 127) << shift
);
16842 if ((byte
& 128) == 0)
16847 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
16848 result
|= -(((LONGEST
) 1) << shift
);
16849 *bytes_read_ptr
= num_read
;
16853 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16854 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16855 ADDR_SIZE is the size of addresses from the CU header. */
16858 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
16860 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16861 bfd
*abfd
= objfile
->obfd
;
16862 const gdb_byte
*info_ptr
;
16864 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
16865 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
16866 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16867 objfile_name (objfile
));
16868 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
16869 error (_("DW_FORM_addr_index pointing outside of "
16870 ".debug_addr section [in module %s]"),
16871 objfile_name (objfile
));
16872 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
16873 + addr_base
+ addr_index
* addr_size
);
16874 if (addr_size
== 4)
16875 return bfd_get_32 (abfd
, info_ptr
);
16877 return bfd_get_64 (abfd
, info_ptr
);
16880 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16883 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
16885 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
16888 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16891 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
16892 unsigned int *bytes_read
)
16894 bfd
*abfd
= cu
->objfile
->obfd
;
16895 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
16897 return read_addr_index (cu
, addr_index
);
16900 /* Data structure to pass results from dwarf2_read_addr_index_reader
16901 back to dwarf2_read_addr_index. */
16903 struct dwarf2_read_addr_index_data
16905 ULONGEST addr_base
;
16909 /* die_reader_func for dwarf2_read_addr_index. */
16912 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
16913 const gdb_byte
*info_ptr
,
16914 struct die_info
*comp_unit_die
,
16918 struct dwarf2_cu
*cu
= reader
->cu
;
16919 struct dwarf2_read_addr_index_data
*aidata
=
16920 (struct dwarf2_read_addr_index_data
*) data
;
16922 aidata
->addr_base
= cu
->addr_base
;
16923 aidata
->addr_size
= cu
->header
.addr_size
;
16926 /* Given an index in .debug_addr, fetch the value.
16927 NOTE: This can be called during dwarf expression evaluation,
16928 long after the debug information has been read, and thus per_cu->cu
16929 may no longer exist. */
16932 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
16933 unsigned int addr_index
)
16935 struct objfile
*objfile
= per_cu
->objfile
;
16936 struct dwarf2_cu
*cu
= per_cu
->cu
;
16937 ULONGEST addr_base
;
16940 /* This is intended to be called from outside this file. */
16941 dw2_setup (objfile
);
16943 /* We need addr_base and addr_size.
16944 If we don't have PER_CU->cu, we have to get it.
16945 Nasty, but the alternative is storing the needed info in PER_CU,
16946 which at this point doesn't seem justified: it's not clear how frequently
16947 it would get used and it would increase the size of every PER_CU.
16948 Entry points like dwarf2_per_cu_addr_size do a similar thing
16949 so we're not in uncharted territory here.
16950 Alas we need to be a bit more complicated as addr_base is contained
16953 We don't need to read the entire CU(/TU).
16954 We just need the header and top level die.
16956 IWBN to use the aging mechanism to let us lazily later discard the CU.
16957 For now we skip this optimization. */
16961 addr_base
= cu
->addr_base
;
16962 addr_size
= cu
->header
.addr_size
;
16966 struct dwarf2_read_addr_index_data aidata
;
16968 /* Note: We can't use init_cutu_and_read_dies_simple here,
16969 we need addr_base. */
16970 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
16971 dwarf2_read_addr_index_reader
, &aidata
);
16972 addr_base
= aidata
.addr_base
;
16973 addr_size
= aidata
.addr_size
;
16976 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
16979 /* Given a DW_FORM_GNU_str_index, fetch the string.
16980 This is only used by the Fission support. */
16982 static const char *
16983 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
16985 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16986 const char *objf_name
= objfile_name (objfile
);
16987 bfd
*abfd
= objfile
->obfd
;
16988 struct dwarf2_cu
*cu
= reader
->cu
;
16989 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
16990 struct dwarf2_section_info
*str_offsets_section
=
16991 &reader
->dwo_file
->sections
.str_offsets
;
16992 const gdb_byte
*info_ptr
;
16993 ULONGEST str_offset
;
16994 static const char form_name
[] = "DW_FORM_GNU_str_index";
16996 dwarf2_read_section (objfile
, str_section
);
16997 dwarf2_read_section (objfile
, str_offsets_section
);
16998 if (str_section
->buffer
== NULL
)
16999 error (_("%s used without .debug_str.dwo section"
17000 " in CU at offset 0x%lx [in module %s]"),
17001 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
17002 if (str_offsets_section
->buffer
== NULL
)
17003 error (_("%s used without .debug_str_offsets.dwo section"
17004 " in CU at offset 0x%lx [in module %s]"),
17005 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
17006 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
17007 error (_("%s pointing outside of .debug_str_offsets.dwo"
17008 " section in CU at offset 0x%lx [in module %s]"),
17009 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
17010 info_ptr
= (str_offsets_section
->buffer
17011 + str_index
* cu
->header
.offset_size
);
17012 if (cu
->header
.offset_size
== 4)
17013 str_offset
= bfd_get_32 (abfd
, info_ptr
);
17015 str_offset
= bfd_get_64 (abfd
, info_ptr
);
17016 if (str_offset
>= str_section
->size
)
17017 error (_("Offset from %s pointing outside of"
17018 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
17019 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
17020 return (const char *) (str_section
->buffer
+ str_offset
);
17023 /* Return the length of an LEB128 number in BUF. */
17026 leb128_size (const gdb_byte
*buf
)
17028 const gdb_byte
*begin
= buf
;
17034 if ((byte
& 128) == 0)
17035 return buf
- begin
;
17040 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
17049 cu
->language
= language_c
;
17052 case DW_LANG_C_plus_plus
:
17053 case DW_LANG_C_plus_plus_11
:
17054 case DW_LANG_C_plus_plus_14
:
17055 cu
->language
= language_cplus
;
17058 cu
->language
= language_d
;
17060 case DW_LANG_Fortran77
:
17061 case DW_LANG_Fortran90
:
17062 case DW_LANG_Fortran95
:
17063 case DW_LANG_Fortran03
:
17064 case DW_LANG_Fortran08
:
17065 cu
->language
= language_fortran
;
17068 cu
->language
= language_go
;
17070 case DW_LANG_Mips_Assembler
:
17071 cu
->language
= language_asm
;
17073 case DW_LANG_Ada83
:
17074 case DW_LANG_Ada95
:
17075 cu
->language
= language_ada
;
17077 case DW_LANG_Modula2
:
17078 cu
->language
= language_m2
;
17080 case DW_LANG_Pascal83
:
17081 cu
->language
= language_pascal
;
17084 cu
->language
= language_objc
;
17087 case DW_LANG_Rust_old
:
17088 cu
->language
= language_rust
;
17090 case DW_LANG_Cobol74
:
17091 case DW_LANG_Cobol85
:
17093 cu
->language
= language_minimal
;
17096 cu
->language_defn
= language_def (cu
->language
);
17099 /* Return the named attribute or NULL if not there. */
17101 static struct attribute
*
17102 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
17107 struct attribute
*spec
= NULL
;
17109 for (i
= 0; i
< die
->num_attrs
; ++i
)
17111 if (die
->attrs
[i
].name
== name
)
17112 return &die
->attrs
[i
];
17113 if (die
->attrs
[i
].name
== DW_AT_specification
17114 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
17115 spec
= &die
->attrs
[i
];
17121 die
= follow_die_ref (die
, spec
, &cu
);
17127 /* Return the named attribute or NULL if not there,
17128 but do not follow DW_AT_specification, etc.
17129 This is for use in contexts where we're reading .debug_types dies.
17130 Following DW_AT_specification, DW_AT_abstract_origin will take us
17131 back up the chain, and we want to go down. */
17133 static struct attribute
*
17134 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
17138 for (i
= 0; i
< die
->num_attrs
; ++i
)
17139 if (die
->attrs
[i
].name
== name
)
17140 return &die
->attrs
[i
];
17145 /* Return the string associated with a string-typed attribute, or NULL if it
17146 is either not found or is of an incorrect type. */
17148 static const char *
17149 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
17151 struct attribute
*attr
;
17152 const char *str
= NULL
;
17154 attr
= dwarf2_attr (die
, name
, cu
);
17158 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_string
17159 || attr
->form
== DW_FORM_GNU_strp_alt
)
17160 str
= DW_STRING (attr
);
17162 complaint (&symfile_complaints
,
17163 _("string type expected for attribute %s for "
17164 "DIE at 0x%x in module %s"),
17165 dwarf_attr_name (name
), die
->offset
.sect_off
,
17166 objfile_name (cu
->objfile
));
17172 /* Return non-zero iff the attribute NAME is defined for the given DIE,
17173 and holds a non-zero value. This function should only be used for
17174 DW_FORM_flag or DW_FORM_flag_present attributes. */
17177 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
17179 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
17181 return (attr
&& DW_UNSND (attr
));
17185 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
17187 /* A DIE is a declaration if it has a DW_AT_declaration attribute
17188 which value is non-zero. However, we have to be careful with
17189 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
17190 (via dwarf2_flag_true_p) follows this attribute. So we may
17191 end up accidently finding a declaration attribute that belongs
17192 to a different DIE referenced by the specification attribute,
17193 even though the given DIE does not have a declaration attribute. */
17194 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
17195 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
17198 /* Return the die giving the specification for DIE, if there is
17199 one. *SPEC_CU is the CU containing DIE on input, and the CU
17200 containing the return value on output. If there is no
17201 specification, but there is an abstract origin, that is
17204 static struct die_info
*
17205 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
17207 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
17210 if (spec_attr
== NULL
)
17211 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
17213 if (spec_attr
== NULL
)
17216 return follow_die_ref (die
, spec_attr
, spec_cu
);
17219 /* Free the line_header structure *LH, and any arrays and strings it
17221 NOTE: This is also used as a "cleanup" function. */
17224 free_line_header (struct line_header
*lh
)
17226 if (lh
->standard_opcode_lengths
)
17227 xfree (lh
->standard_opcode_lengths
);
17229 /* Remember that all the lh->file_names[i].name pointers are
17230 pointers into debug_line_buffer, and don't need to be freed. */
17231 if (lh
->file_names
)
17232 xfree (lh
->file_names
);
17234 /* Similarly for the include directory names. */
17235 if (lh
->include_dirs
)
17236 xfree (lh
->include_dirs
);
17241 /* Stub for free_line_header to match void * callback types. */
17244 free_line_header_voidp (void *arg
)
17246 struct line_header
*lh
= (struct line_header
*) arg
;
17248 free_line_header (lh
);
17251 /* Add an entry to LH's include directory table. */
17254 add_include_dir (struct line_header
*lh
, const char *include_dir
)
17256 if (dwarf_line_debug
>= 2)
17257 fprintf_unfiltered (gdb_stdlog
, "Adding dir %u: %s\n",
17258 lh
->num_include_dirs
+ 1, include_dir
);
17260 /* Grow the array if necessary. */
17261 if (lh
->include_dirs_size
== 0)
17263 lh
->include_dirs_size
= 1; /* for testing */
17264 lh
->include_dirs
= XNEWVEC (const char *, lh
->include_dirs_size
);
17266 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
17268 lh
->include_dirs_size
*= 2;
17269 lh
->include_dirs
= XRESIZEVEC (const char *, lh
->include_dirs
,
17270 lh
->include_dirs_size
);
17273 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
17276 /* Add an entry to LH's file name table. */
17279 add_file_name (struct line_header
*lh
,
17281 unsigned int dir_index
,
17282 unsigned int mod_time
,
17283 unsigned int length
)
17285 struct file_entry
*fe
;
17287 if (dwarf_line_debug
>= 2)
17288 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
17289 lh
->num_file_names
+ 1, name
);
17291 /* Grow the array if necessary. */
17292 if (lh
->file_names_size
== 0)
17294 lh
->file_names_size
= 1; /* for testing */
17295 lh
->file_names
= XNEWVEC (struct file_entry
, lh
->file_names_size
);
17297 else if (lh
->num_file_names
>= lh
->file_names_size
)
17299 lh
->file_names_size
*= 2;
17301 = XRESIZEVEC (struct file_entry
, lh
->file_names
, lh
->file_names_size
);
17304 fe
= &lh
->file_names
[lh
->num_file_names
++];
17306 fe
->dir_index
= dir_index
;
17307 fe
->mod_time
= mod_time
;
17308 fe
->length
= length
;
17309 fe
->included_p
= 0;
17313 /* A convenience function to find the proper .debug_line section for a CU. */
17315 static struct dwarf2_section_info
*
17316 get_debug_line_section (struct dwarf2_cu
*cu
)
17318 struct dwarf2_section_info
*section
;
17320 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
17322 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17323 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
17324 else if (cu
->per_cu
->is_dwz
)
17326 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17328 section
= &dwz
->line
;
17331 section
= &dwarf2_per_objfile
->line
;
17336 /* Read the statement program header starting at OFFSET in
17337 .debug_line, or .debug_line.dwo. Return a pointer
17338 to a struct line_header, allocated using xmalloc.
17339 Returns NULL if there is a problem reading the header, e.g., if it
17340 has a version we don't understand.
17342 NOTE: the strings in the include directory and file name tables of
17343 the returned object point into the dwarf line section buffer,
17344 and must not be freed. */
17346 static struct line_header
*
17347 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
17349 struct cleanup
*back_to
;
17350 struct line_header
*lh
;
17351 const gdb_byte
*line_ptr
;
17352 unsigned int bytes_read
, offset_size
;
17354 const char *cur_dir
, *cur_file
;
17355 struct dwarf2_section_info
*section
;
17358 section
= get_debug_line_section (cu
);
17359 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
17360 if (section
->buffer
== NULL
)
17362 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17363 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
17365 complaint (&symfile_complaints
, _("missing .debug_line section"));
17369 /* We can't do this until we know the section is non-empty.
17370 Only then do we know we have such a section. */
17371 abfd
= get_section_bfd_owner (section
);
17373 /* Make sure that at least there's room for the total_length field.
17374 That could be 12 bytes long, but we're just going to fudge that. */
17375 if (offset
+ 4 >= section
->size
)
17377 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17381 lh
= XNEW (struct line_header
);
17382 memset (lh
, 0, sizeof (*lh
));
17383 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
17386 lh
->offset
.sect_off
= offset
;
17387 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
17389 line_ptr
= section
->buffer
+ offset
;
17391 /* Read in the header. */
17393 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
17394 &bytes_read
, &offset_size
);
17395 line_ptr
+= bytes_read
;
17396 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
17398 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17399 do_cleanups (back_to
);
17402 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
17403 lh
->version
= read_2_bytes (abfd
, line_ptr
);
17405 if (lh
->version
> 4)
17407 /* This is a version we don't understand. The format could have
17408 changed in ways we don't handle properly so just punt. */
17409 complaint (&symfile_complaints
,
17410 _("unsupported version in .debug_line section"));
17413 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
17414 line_ptr
+= offset_size
;
17415 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
17417 if (lh
->version
>= 4)
17419 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
17423 lh
->maximum_ops_per_instruction
= 1;
17425 if (lh
->maximum_ops_per_instruction
== 0)
17427 lh
->maximum_ops_per_instruction
= 1;
17428 complaint (&symfile_complaints
,
17429 _("invalid maximum_ops_per_instruction "
17430 "in `.debug_line' section"));
17433 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
17435 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
17437 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
17439 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
17441 lh
->standard_opcode_lengths
= XNEWVEC (unsigned char, lh
->opcode_base
);
17443 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
17444 for (i
= 1; i
< lh
->opcode_base
; ++i
)
17446 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
17450 /* Read directory table. */
17451 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17453 line_ptr
+= bytes_read
;
17454 add_include_dir (lh
, cur_dir
);
17456 line_ptr
+= bytes_read
;
17458 /* Read file name table. */
17459 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17461 unsigned int dir_index
, mod_time
, length
;
17463 line_ptr
+= bytes_read
;
17464 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17465 line_ptr
+= bytes_read
;
17466 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17467 line_ptr
+= bytes_read
;
17468 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17469 line_ptr
+= bytes_read
;
17471 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17473 line_ptr
+= bytes_read
;
17474 lh
->statement_program_start
= line_ptr
;
17476 if (line_ptr
> (section
->buffer
+ section
->size
))
17477 complaint (&symfile_complaints
,
17478 _("line number info header doesn't "
17479 "fit in `.debug_line' section"));
17481 discard_cleanups (back_to
);
17485 /* Subroutine of dwarf_decode_lines to simplify it.
17486 Return the file name of the psymtab for included file FILE_INDEX
17487 in line header LH of PST.
17488 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17489 If space for the result is malloc'd, it will be freed by a cleanup.
17490 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17492 The function creates dangling cleanup registration. */
17494 static const char *
17495 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
17496 const struct partial_symtab
*pst
,
17497 const char *comp_dir
)
17499 const struct file_entry fe
= lh
->file_names
[file_index
];
17500 const char *include_name
= fe
.name
;
17501 const char *include_name_to_compare
= include_name
;
17502 const char *dir_name
= NULL
;
17503 const char *pst_filename
;
17504 char *copied_name
= NULL
;
17507 if (fe
.dir_index
&& lh
->include_dirs
!= NULL
)
17508 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
17510 if (!IS_ABSOLUTE_PATH (include_name
)
17511 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
17513 /* Avoid creating a duplicate psymtab for PST.
17514 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17515 Before we do the comparison, however, we need to account
17516 for DIR_NAME and COMP_DIR.
17517 First prepend dir_name (if non-NULL). If we still don't
17518 have an absolute path prepend comp_dir (if non-NULL).
17519 However, the directory we record in the include-file's
17520 psymtab does not contain COMP_DIR (to match the
17521 corresponding symtab(s)).
17526 bash$ gcc -g ./hello.c
17527 include_name = "hello.c"
17529 DW_AT_comp_dir = comp_dir = "/tmp"
17530 DW_AT_name = "./hello.c"
17534 if (dir_name
!= NULL
)
17536 char *tem
= concat (dir_name
, SLASH_STRING
,
17537 include_name
, (char *)NULL
);
17539 make_cleanup (xfree
, tem
);
17540 include_name
= tem
;
17541 include_name_to_compare
= include_name
;
17543 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
17545 char *tem
= concat (comp_dir
, SLASH_STRING
,
17546 include_name
, (char *)NULL
);
17548 make_cleanup (xfree
, tem
);
17549 include_name_to_compare
= tem
;
17553 pst_filename
= pst
->filename
;
17554 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
17556 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
17557 pst_filename
, (char *)NULL
);
17558 pst_filename
= copied_name
;
17561 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
17563 if (copied_name
!= NULL
)
17564 xfree (copied_name
);
17568 return include_name
;
17571 /* State machine to track the state of the line number program. */
17575 /* These are part of the standard DWARF line number state machine. */
17577 unsigned char op_index
;
17582 unsigned int discriminator
;
17584 /* Additional bits of state we need to track. */
17586 /* The last file that we called dwarf2_start_subfile for.
17587 This is only used for TLLs. */
17588 unsigned int last_file
;
17589 /* The last file a line number was recorded for. */
17590 struct subfile
*last_subfile
;
17592 /* The function to call to record a line. */
17593 record_line_ftype
*record_line
;
17595 /* The last line number that was recorded, used to coalesce
17596 consecutive entries for the same line. This can happen, for
17597 example, when discriminators are present. PR 17276. */
17598 unsigned int last_line
;
17599 int line_has_non_zero_discriminator
;
17600 } lnp_state_machine
;
17602 /* There's a lot of static state to pass to dwarf_record_line.
17603 This keeps it all together. */
17608 struct gdbarch
*gdbarch
;
17610 /* The line number header. */
17611 struct line_header
*line_header
;
17613 /* Non-zero if we're recording lines.
17614 Otherwise we're building partial symtabs and are just interested in
17615 finding include files mentioned by the line number program. */
17616 int record_lines_p
;
17617 } lnp_reader_state
;
17619 /* Ignore this record_line request. */
17622 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17627 /* Return non-zero if we should add LINE to the line number table.
17628 LINE is the line to add, LAST_LINE is the last line that was added,
17629 LAST_SUBFILE is the subfile for LAST_LINE.
17630 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17631 had a non-zero discriminator.
17633 We have to be careful in the presence of discriminators.
17634 E.g., for this line:
17636 for (i = 0; i < 100000; i++);
17638 clang can emit four line number entries for that one line,
17639 each with a different discriminator.
17640 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17642 However, we want gdb to coalesce all four entries into one.
17643 Otherwise the user could stepi into the middle of the line and
17644 gdb would get confused about whether the pc really was in the
17645 middle of the line.
17647 Things are further complicated by the fact that two consecutive
17648 line number entries for the same line is a heuristic used by gcc
17649 to denote the end of the prologue. So we can't just discard duplicate
17650 entries, we have to be selective about it. The heuristic we use is
17651 that we only collapse consecutive entries for the same line if at least
17652 one of those entries has a non-zero discriminator. PR 17276.
17654 Note: Addresses in the line number state machine can never go backwards
17655 within one sequence, thus this coalescing is ok. */
17658 dwarf_record_line_p (unsigned int line
, unsigned int last_line
,
17659 int line_has_non_zero_discriminator
,
17660 struct subfile
*last_subfile
)
17662 if (current_subfile
!= last_subfile
)
17664 if (line
!= last_line
)
17666 /* Same line for the same file that we've seen already.
17667 As a last check, for pr 17276, only record the line if the line
17668 has never had a non-zero discriminator. */
17669 if (!line_has_non_zero_discriminator
)
17674 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17675 in the line table of subfile SUBFILE. */
17678 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17679 unsigned int line
, CORE_ADDR address
,
17680 record_line_ftype p_record_line
)
17682 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17684 if (dwarf_line_debug
)
17686 fprintf_unfiltered (gdb_stdlog
,
17687 "Recording line %u, file %s, address %s\n",
17688 line
, lbasename (subfile
->name
),
17689 paddress (gdbarch
, address
));
17692 (*p_record_line
) (subfile
, line
, addr
);
17695 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17696 Mark the end of a set of line number records.
17697 The arguments are the same as for dwarf_record_line_1.
17698 If SUBFILE is NULL the request is ignored. */
17701 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17702 CORE_ADDR address
, record_line_ftype p_record_line
)
17704 if (subfile
== NULL
)
17707 if (dwarf_line_debug
)
17709 fprintf_unfiltered (gdb_stdlog
,
17710 "Finishing current line, file %s, address %s\n",
17711 lbasename (subfile
->name
),
17712 paddress (gdbarch
, address
));
17715 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, p_record_line
);
17718 /* Record the line in STATE.
17719 END_SEQUENCE is non-zero if we're processing the end of a sequence. */
17722 dwarf_record_line (lnp_reader_state
*reader
, lnp_state_machine
*state
,
17725 const struct line_header
*lh
= reader
->line_header
;
17726 unsigned int file
, line
, discriminator
;
17729 file
= state
->file
;
17730 line
= state
->line
;
17731 is_stmt
= state
->is_stmt
;
17732 discriminator
= state
->discriminator
;
17734 if (dwarf_line_debug
)
17736 fprintf_unfiltered (gdb_stdlog
,
17737 "Processing actual line %u: file %u,"
17738 " address %s, is_stmt %u, discrim %u\n",
17740 paddress (reader
->gdbarch
, state
->address
),
17741 is_stmt
, discriminator
);
17744 if (file
== 0 || file
- 1 >= lh
->num_file_names
)
17745 dwarf2_debug_line_missing_file_complaint ();
17746 /* For now we ignore lines not starting on an instruction boundary.
17747 But not when processing end_sequence for compatibility with the
17748 previous version of the code. */
17749 else if (state
->op_index
== 0 || end_sequence
)
17751 lh
->file_names
[file
- 1].included_p
= 1;
17752 if (reader
->record_lines_p
&& is_stmt
)
17754 if (state
->last_subfile
!= current_subfile
|| end_sequence
)
17756 dwarf_finish_line (reader
->gdbarch
, state
->last_subfile
,
17757 state
->address
, state
->record_line
);
17762 if (dwarf_record_line_p (line
, state
->last_line
,
17763 state
->line_has_non_zero_discriminator
,
17764 state
->last_subfile
))
17766 dwarf_record_line_1 (reader
->gdbarch
, current_subfile
,
17767 line
, state
->address
,
17768 state
->record_line
);
17770 state
->last_subfile
= current_subfile
;
17771 state
->last_line
= line
;
17777 /* Initialize STATE for the start of a line number program. */
17780 init_lnp_state_machine (lnp_state_machine
*state
,
17781 const lnp_reader_state
*reader
)
17783 memset (state
, 0, sizeof (*state
));
17785 /* Just starting, there is no "last file". */
17786 state
->last_file
= 0;
17787 state
->last_subfile
= NULL
;
17789 state
->record_line
= record_line
;
17791 state
->last_line
= 0;
17792 state
->line_has_non_zero_discriminator
= 0;
17794 /* Initialize these according to the DWARF spec. */
17795 state
->op_index
= 0;
17798 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
17799 was a line entry for it so that the backend has a chance to adjust it
17800 and also record it in case it needs it. This is currently used by MIPS
17801 code, cf. `mips_adjust_dwarf2_line'. */
17802 state
->address
= gdbarch_adjust_dwarf2_line (reader
->gdbarch
, 0, 0);
17803 state
->is_stmt
= reader
->line_header
->default_is_stmt
;
17804 state
->discriminator
= 0;
17807 /* Check address and if invalid nop-out the rest of the lines in this
17811 check_line_address (struct dwarf2_cu
*cu
, lnp_state_machine
*state
,
17812 const gdb_byte
*line_ptr
,
17813 CORE_ADDR lowpc
, CORE_ADDR address
)
17815 /* If address < lowpc then it's not a usable value, it's outside the
17816 pc range of the CU. However, we restrict the test to only address
17817 values of zero to preserve GDB's previous behaviour which is to
17818 handle the specific case of a function being GC'd by the linker. */
17820 if (address
== 0 && address
< lowpc
)
17822 /* This line table is for a function which has been
17823 GCd by the linker. Ignore it. PR gdb/12528 */
17825 struct objfile
*objfile
= cu
->objfile
;
17826 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
17828 complaint (&symfile_complaints
,
17829 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
17830 line_offset
, objfile_name (objfile
));
17831 state
->record_line
= noop_record_line
;
17832 /* Note: sm.record_line is left as noop_record_line
17833 until we see DW_LNE_end_sequence. */
17837 /* Subroutine of dwarf_decode_lines to simplify it.
17838 Process the line number information in LH.
17839 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
17840 program in order to set included_p for every referenced header. */
17843 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
17844 const int decode_for_pst_p
, CORE_ADDR lowpc
)
17846 const gdb_byte
*line_ptr
, *extended_end
;
17847 const gdb_byte
*line_end
;
17848 unsigned int bytes_read
, extended_len
;
17849 unsigned char op_code
, extended_op
;
17850 CORE_ADDR baseaddr
;
17851 struct objfile
*objfile
= cu
->objfile
;
17852 bfd
*abfd
= objfile
->obfd
;
17853 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17854 /* Non-zero if we're recording line info (as opposed to building partial
17856 int record_lines_p
= !decode_for_pst_p
;
17857 /* A collection of things we need to pass to dwarf_record_line. */
17858 lnp_reader_state reader_state
;
17860 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17862 line_ptr
= lh
->statement_program_start
;
17863 line_end
= lh
->statement_program_end
;
17865 reader_state
.gdbarch
= gdbarch
;
17866 reader_state
.line_header
= lh
;
17867 reader_state
.record_lines_p
= record_lines_p
;
17869 /* Read the statement sequences until there's nothing left. */
17870 while (line_ptr
< line_end
)
17872 /* The DWARF line number program state machine. */
17873 lnp_state_machine state_machine
;
17874 int end_sequence
= 0;
17876 /* Reset the state machine at the start of each sequence. */
17877 init_lnp_state_machine (&state_machine
, &reader_state
);
17879 if (record_lines_p
&& lh
->num_file_names
>= state_machine
.file
)
17881 /* Start a subfile for the current file of the state machine. */
17882 /* lh->include_dirs and lh->file_names are 0-based, but the
17883 directory and file name numbers in the statement program
17885 struct file_entry
*fe
= &lh
->file_names
[state_machine
.file
- 1];
17886 const char *dir
= NULL
;
17888 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
17889 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17891 dwarf2_start_subfile (fe
->name
, dir
);
17894 /* Decode the table. */
17895 while (line_ptr
< line_end
&& !end_sequence
)
17897 op_code
= read_1_byte (abfd
, line_ptr
);
17900 if (op_code
>= lh
->opcode_base
)
17902 /* Special opcode. */
17903 unsigned char adj_opcode
;
17904 CORE_ADDR addr_adj
;
17907 adj_opcode
= op_code
- lh
->opcode_base
;
17908 addr_adj
= (((state_machine
.op_index
17909 + (adj_opcode
/ lh
->line_range
))
17910 / lh
->maximum_ops_per_instruction
)
17911 * lh
->minimum_instruction_length
);
17912 state_machine
.address
17913 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17914 state_machine
.op_index
= ((state_machine
.op_index
17915 + (adj_opcode
/ lh
->line_range
))
17916 % lh
->maximum_ops_per_instruction
);
17917 line_delta
= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
17918 state_machine
.line
+= line_delta
;
17919 if (line_delta
!= 0)
17920 state_machine
.line_has_non_zero_discriminator
17921 = state_machine
.discriminator
!= 0;
17923 dwarf_record_line (&reader_state
, &state_machine
, 0);
17924 state_machine
.discriminator
= 0;
17926 else switch (op_code
)
17928 case DW_LNS_extended_op
:
17929 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
17931 line_ptr
+= bytes_read
;
17932 extended_end
= line_ptr
+ extended_len
;
17933 extended_op
= read_1_byte (abfd
, line_ptr
);
17935 switch (extended_op
)
17937 case DW_LNE_end_sequence
:
17938 state_machine
.record_line
= record_line
;
17941 case DW_LNE_set_address
:
17944 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
17946 line_ptr
+= bytes_read
;
17947 check_line_address (cu
, &state_machine
, line_ptr
,
17949 state_machine
.op_index
= 0;
17950 address
+= baseaddr
;
17951 state_machine
.address
17952 = gdbarch_adjust_dwarf2_line (gdbarch
, address
, 0);
17955 case DW_LNE_define_file
:
17957 const char *cur_file
;
17958 unsigned int dir_index
, mod_time
, length
;
17960 cur_file
= read_direct_string (abfd
, line_ptr
,
17962 line_ptr
+= bytes_read
;
17964 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17965 line_ptr
+= bytes_read
;
17967 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17968 line_ptr
+= bytes_read
;
17970 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17971 line_ptr
+= bytes_read
;
17972 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17975 case DW_LNE_set_discriminator
:
17976 /* The discriminator is not interesting to the debugger;
17977 just ignore it. We still need to check its value though:
17978 if there are consecutive entries for the same
17979 (non-prologue) line we want to coalesce them.
17981 state_machine
.discriminator
17982 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17983 state_machine
.line_has_non_zero_discriminator
17984 |= state_machine
.discriminator
!= 0;
17985 line_ptr
+= bytes_read
;
17988 complaint (&symfile_complaints
,
17989 _("mangled .debug_line section"));
17992 /* Make sure that we parsed the extended op correctly. If e.g.
17993 we expected a different address size than the producer used,
17994 we may have read the wrong number of bytes. */
17995 if (line_ptr
!= extended_end
)
17997 complaint (&symfile_complaints
,
17998 _("mangled .debug_line section"));
18003 dwarf_record_line (&reader_state
, &state_machine
, 0);
18004 state_machine
.discriminator
= 0;
18006 case DW_LNS_advance_pc
:
18009 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18010 CORE_ADDR addr_adj
;
18012 addr_adj
= (((state_machine
.op_index
+ adjust
)
18013 / lh
->maximum_ops_per_instruction
)
18014 * lh
->minimum_instruction_length
);
18015 state_machine
.address
18016 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18017 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
18018 % lh
->maximum_ops_per_instruction
);
18019 line_ptr
+= bytes_read
;
18022 case DW_LNS_advance_line
:
18025 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
18027 state_machine
.line
+= line_delta
;
18028 if (line_delta
!= 0)
18029 state_machine
.line_has_non_zero_discriminator
18030 = state_machine
.discriminator
!= 0;
18031 line_ptr
+= bytes_read
;
18034 case DW_LNS_set_file
:
18036 /* The arrays lh->include_dirs and lh->file_names are
18037 0-based, but the directory and file name numbers in
18038 the statement program are 1-based. */
18039 struct file_entry
*fe
;
18040 const char *dir
= NULL
;
18042 state_machine
.file
= read_unsigned_leb128 (abfd
, line_ptr
,
18044 line_ptr
+= bytes_read
;
18045 if (state_machine
.file
== 0
18046 || state_machine
.file
- 1 >= lh
->num_file_names
)
18047 dwarf2_debug_line_missing_file_complaint ();
18050 fe
= &lh
->file_names
[state_machine
.file
- 1];
18051 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
18052 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
18053 if (record_lines_p
)
18055 state_machine
.last_subfile
= current_subfile
;
18056 state_machine
.line_has_non_zero_discriminator
18057 = state_machine
.discriminator
!= 0;
18058 dwarf2_start_subfile (fe
->name
, dir
);
18063 case DW_LNS_set_column
:
18064 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18065 line_ptr
+= bytes_read
;
18067 case DW_LNS_negate_stmt
:
18068 state_machine
.is_stmt
= (!state_machine
.is_stmt
);
18070 case DW_LNS_set_basic_block
:
18072 /* Add to the address register of the state machine the
18073 address increment value corresponding to special opcode
18074 255. I.e., this value is scaled by the minimum
18075 instruction length since special opcode 255 would have
18076 scaled the increment. */
18077 case DW_LNS_const_add_pc
:
18079 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
18080 CORE_ADDR addr_adj
;
18082 addr_adj
= (((state_machine
.op_index
+ adjust
)
18083 / lh
->maximum_ops_per_instruction
)
18084 * lh
->minimum_instruction_length
);
18085 state_machine
.address
18086 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18087 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
18088 % lh
->maximum_ops_per_instruction
);
18091 case DW_LNS_fixed_advance_pc
:
18093 CORE_ADDR addr_adj
;
18095 addr_adj
= read_2_bytes (abfd
, line_ptr
);
18096 state_machine
.address
18097 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18098 state_machine
.op_index
= 0;
18104 /* Unknown standard opcode, ignore it. */
18107 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
18109 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18110 line_ptr
+= bytes_read
;
18117 dwarf2_debug_line_missing_end_sequence_complaint ();
18119 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
18120 in which case we still finish recording the last line). */
18121 dwarf_record_line (&reader_state
, &state_machine
, 1);
18125 /* Decode the Line Number Program (LNP) for the given line_header
18126 structure and CU. The actual information extracted and the type
18127 of structures created from the LNP depends on the value of PST.
18129 1. If PST is NULL, then this procedure uses the data from the program
18130 to create all necessary symbol tables, and their linetables.
18132 2. If PST is not NULL, this procedure reads the program to determine
18133 the list of files included by the unit represented by PST, and
18134 builds all the associated partial symbol tables.
18136 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
18137 It is used for relative paths in the line table.
18138 NOTE: When processing partial symtabs (pst != NULL),
18139 comp_dir == pst->dirname.
18141 NOTE: It is important that psymtabs have the same file name (via strcmp)
18142 as the corresponding symtab. Since COMP_DIR is not used in the name of the
18143 symtab we don't use it in the name of the psymtabs we create.
18144 E.g. expand_line_sal requires this when finding psymtabs to expand.
18145 A good testcase for this is mb-inline.exp.
18147 LOWPC is the lowest address in CU (or 0 if not known).
18149 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
18150 for its PC<->lines mapping information. Otherwise only the filename
18151 table is read in. */
18154 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
18155 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
18156 CORE_ADDR lowpc
, int decode_mapping
)
18158 struct objfile
*objfile
= cu
->objfile
;
18159 const int decode_for_pst_p
= (pst
!= NULL
);
18161 if (decode_mapping
)
18162 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
18164 if (decode_for_pst_p
)
18168 /* Now that we're done scanning the Line Header Program, we can
18169 create the psymtab of each included file. */
18170 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
18171 if (lh
->file_names
[file_index
].included_p
== 1)
18173 const char *include_name
=
18174 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
18175 if (include_name
!= NULL
)
18176 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
18181 /* Make sure a symtab is created for every file, even files
18182 which contain only variables (i.e. no code with associated
18184 struct compunit_symtab
*cust
= buildsym_compunit_symtab ();
18187 for (i
= 0; i
< lh
->num_file_names
; i
++)
18189 const char *dir
= NULL
;
18190 struct file_entry
*fe
;
18192 fe
= &lh
->file_names
[i
];
18193 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
18194 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
18195 dwarf2_start_subfile (fe
->name
, dir
);
18197 if (current_subfile
->symtab
== NULL
)
18199 current_subfile
->symtab
18200 = allocate_symtab (cust
, current_subfile
->name
);
18202 fe
->symtab
= current_subfile
->symtab
;
18207 /* Start a subfile for DWARF. FILENAME is the name of the file and
18208 DIRNAME the name of the source directory which contains FILENAME
18209 or NULL if not known.
18210 This routine tries to keep line numbers from identical absolute and
18211 relative file names in a common subfile.
18213 Using the `list' example from the GDB testsuite, which resides in
18214 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
18215 of /srcdir/list0.c yields the following debugging information for list0.c:
18217 DW_AT_name: /srcdir/list0.c
18218 DW_AT_comp_dir: /compdir
18219 files.files[0].name: list0.h
18220 files.files[0].dir: /srcdir
18221 files.files[1].name: list0.c
18222 files.files[1].dir: /srcdir
18224 The line number information for list0.c has to end up in a single
18225 subfile, so that `break /srcdir/list0.c:1' works as expected.
18226 start_subfile will ensure that this happens provided that we pass the
18227 concatenation of files.files[1].dir and files.files[1].name as the
18231 dwarf2_start_subfile (const char *filename
, const char *dirname
)
18235 /* In order not to lose the line information directory,
18236 we concatenate it to the filename when it makes sense.
18237 Note that the Dwarf3 standard says (speaking of filenames in line
18238 information): ``The directory index is ignored for file names
18239 that represent full path names''. Thus ignoring dirname in the
18240 `else' branch below isn't an issue. */
18242 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
18244 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
18248 start_subfile (filename
);
18254 /* Start a symtab for DWARF.
18255 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
18257 static struct compunit_symtab
*
18258 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
18259 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
18261 struct compunit_symtab
*cust
18262 = start_symtab (cu
->objfile
, name
, comp_dir
, low_pc
);
18264 record_debugformat ("DWARF 2");
18265 record_producer (cu
->producer
);
18267 /* We assume that we're processing GCC output. */
18268 processing_gcc_compilation
= 2;
18270 cu
->processing_has_namespace_info
= 0;
18276 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
18277 struct dwarf2_cu
*cu
)
18279 struct objfile
*objfile
= cu
->objfile
;
18280 struct comp_unit_head
*cu_header
= &cu
->header
;
18282 /* NOTE drow/2003-01-30: There used to be a comment and some special
18283 code here to turn a symbol with DW_AT_external and a
18284 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
18285 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
18286 with some versions of binutils) where shared libraries could have
18287 relocations against symbols in their debug information - the
18288 minimal symbol would have the right address, but the debug info
18289 would not. It's no longer necessary, because we will explicitly
18290 apply relocations when we read in the debug information now. */
18292 /* A DW_AT_location attribute with no contents indicates that a
18293 variable has been optimized away. */
18294 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
18296 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18300 /* Handle one degenerate form of location expression specially, to
18301 preserve GDB's previous behavior when section offsets are
18302 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
18303 then mark this symbol as LOC_STATIC. */
18305 if (attr_form_is_block (attr
)
18306 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
18307 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
18308 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
18309 && (DW_BLOCK (attr
)->size
18310 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
18312 unsigned int dummy
;
18314 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
18315 SYMBOL_VALUE_ADDRESS (sym
) =
18316 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
18318 SYMBOL_VALUE_ADDRESS (sym
) =
18319 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
18320 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
18321 fixup_symbol_section (sym
, objfile
);
18322 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
18323 SYMBOL_SECTION (sym
));
18327 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
18328 expression evaluator, and use LOC_COMPUTED only when necessary
18329 (i.e. when the value of a register or memory location is
18330 referenced, or a thread-local block, etc.). Then again, it might
18331 not be worthwhile. I'm assuming that it isn't unless performance
18332 or memory numbers show me otherwise. */
18334 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
18336 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
18337 cu
->has_loclist
= 1;
18340 /* Given a pointer to a DWARF information entry, figure out if we need
18341 to make a symbol table entry for it, and if so, create a new entry
18342 and return a pointer to it.
18343 If TYPE is NULL, determine symbol type from the die, otherwise
18344 used the passed type.
18345 If SPACE is not NULL, use it to hold the new symbol. If it is
18346 NULL, allocate a new symbol on the objfile's obstack. */
18348 static struct symbol
*
18349 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
18350 struct symbol
*space
)
18352 struct objfile
*objfile
= cu
->objfile
;
18353 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18354 struct symbol
*sym
= NULL
;
18356 struct attribute
*attr
= NULL
;
18357 struct attribute
*attr2
= NULL
;
18358 CORE_ADDR baseaddr
;
18359 struct pending
**list_to_add
= NULL
;
18361 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
18363 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
18365 name
= dwarf2_name (die
, cu
);
18368 const char *linkagename
;
18369 int suppress_add
= 0;
18374 sym
= allocate_symbol (objfile
);
18375 OBJSTAT (objfile
, n_syms
++);
18377 /* Cache this symbol's name and the name's demangled form (if any). */
18378 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
18379 linkagename
= dwarf2_physname (name
, die
, cu
);
18380 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
18382 /* Fortran does not have mangling standard and the mangling does differ
18383 between gfortran, iFort etc. */
18384 if (cu
->language
== language_fortran
18385 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
18386 symbol_set_demangled_name (&(sym
->ginfo
),
18387 dwarf2_full_name (name
, die
, cu
),
18390 /* Default assumptions.
18391 Use the passed type or decode it from the die. */
18392 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18393 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18395 SYMBOL_TYPE (sym
) = type
;
18397 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
18398 attr
= dwarf2_attr (die
,
18399 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
18403 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
18406 attr
= dwarf2_attr (die
,
18407 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
18411 int file_index
= DW_UNSND (attr
);
18413 if (cu
->line_header
== NULL
18414 || file_index
> cu
->line_header
->num_file_names
)
18415 complaint (&symfile_complaints
,
18416 _("file index out of range"));
18417 else if (file_index
> 0)
18419 struct file_entry
*fe
;
18421 fe
= &cu
->line_header
->file_names
[file_index
- 1];
18422 symbol_set_symtab (sym
, fe
->symtab
);
18429 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
18434 addr
= attr_value_as_address (attr
);
18435 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
18436 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
18438 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
18439 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
18440 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
18441 add_symbol_to_list (sym
, cu
->list_in_scope
);
18443 case DW_TAG_subprogram
:
18444 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18446 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18447 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18448 if ((attr2
&& (DW_UNSND (attr2
) != 0))
18449 || cu
->language
== language_ada
)
18451 /* Subprograms marked external are stored as a global symbol.
18452 Ada subprograms, whether marked external or not, are always
18453 stored as a global symbol, because we want to be able to
18454 access them globally. For instance, we want to be able
18455 to break on a nested subprogram without having to
18456 specify the context. */
18457 list_to_add
= &global_symbols
;
18461 list_to_add
= cu
->list_in_scope
;
18464 case DW_TAG_inlined_subroutine
:
18465 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18467 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18468 SYMBOL_INLINED (sym
) = 1;
18469 list_to_add
= cu
->list_in_scope
;
18471 case DW_TAG_template_value_param
:
18473 /* Fall through. */
18474 case DW_TAG_constant
:
18475 case DW_TAG_variable
:
18476 case DW_TAG_member
:
18477 /* Compilation with minimal debug info may result in
18478 variables with missing type entries. Change the
18479 misleading `void' type to something sensible. */
18480 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
18482 = objfile_type (objfile
)->nodebug_data_symbol
;
18484 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18485 /* In the case of DW_TAG_member, we should only be called for
18486 static const members. */
18487 if (die
->tag
== DW_TAG_member
)
18489 /* dwarf2_add_field uses die_is_declaration,
18490 so we do the same. */
18491 gdb_assert (die_is_declaration (die
, cu
));
18496 dwarf2_const_value (attr
, sym
, cu
);
18497 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18500 if (attr2
&& (DW_UNSND (attr2
) != 0))
18501 list_to_add
= &global_symbols
;
18503 list_to_add
= cu
->list_in_scope
;
18507 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18510 var_decode_location (attr
, sym
, cu
);
18511 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18513 /* Fortran explicitly imports any global symbols to the local
18514 scope by DW_TAG_common_block. */
18515 if (cu
->language
== language_fortran
&& die
->parent
18516 && die
->parent
->tag
== DW_TAG_common_block
)
18519 if (SYMBOL_CLASS (sym
) == LOC_STATIC
18520 && SYMBOL_VALUE_ADDRESS (sym
) == 0
18521 && !dwarf2_per_objfile
->has_section_at_zero
)
18523 /* When a static variable is eliminated by the linker,
18524 the corresponding debug information is not stripped
18525 out, but the variable address is set to null;
18526 do not add such variables into symbol table. */
18528 else if (attr2
&& (DW_UNSND (attr2
) != 0))
18530 /* Workaround gfortran PR debug/40040 - it uses
18531 DW_AT_location for variables in -fPIC libraries which may
18532 get overriden by other libraries/executable and get
18533 a different address. Resolve it by the minimal symbol
18534 which may come from inferior's executable using copy
18535 relocation. Make this workaround only for gfortran as for
18536 other compilers GDB cannot guess the minimal symbol
18537 Fortran mangling kind. */
18538 if (cu
->language
== language_fortran
&& die
->parent
18539 && die
->parent
->tag
== DW_TAG_module
18541 && startswith (cu
->producer
, "GNU Fortran"))
18542 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18544 /* A variable with DW_AT_external is never static,
18545 but it may be block-scoped. */
18546 list_to_add
= (cu
->list_in_scope
== &file_symbols
18547 ? &global_symbols
: cu
->list_in_scope
);
18550 list_to_add
= cu
->list_in_scope
;
18554 /* We do not know the address of this symbol.
18555 If it is an external symbol and we have type information
18556 for it, enter the symbol as a LOC_UNRESOLVED symbol.
18557 The address of the variable will then be determined from
18558 the minimal symbol table whenever the variable is
18560 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18562 /* Fortran explicitly imports any global symbols to the local
18563 scope by DW_TAG_common_block. */
18564 if (cu
->language
== language_fortran
&& die
->parent
18565 && die
->parent
->tag
== DW_TAG_common_block
)
18567 /* SYMBOL_CLASS doesn't matter here because
18568 read_common_block is going to reset it. */
18570 list_to_add
= cu
->list_in_scope
;
18572 else if (attr2
&& (DW_UNSND (attr2
) != 0)
18573 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
18575 /* A variable with DW_AT_external is never static, but it
18576 may be block-scoped. */
18577 list_to_add
= (cu
->list_in_scope
== &file_symbols
18578 ? &global_symbols
: cu
->list_in_scope
);
18580 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18582 else if (!die_is_declaration (die
, cu
))
18584 /* Use the default LOC_OPTIMIZED_OUT class. */
18585 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
18587 list_to_add
= cu
->list_in_scope
;
18591 case DW_TAG_formal_parameter
:
18592 /* If we are inside a function, mark this as an argument. If
18593 not, we might be looking at an argument to an inlined function
18594 when we do not have enough information to show inlined frames;
18595 pretend it's a local variable in that case so that the user can
18597 if (context_stack_depth
> 0
18598 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
18599 SYMBOL_IS_ARGUMENT (sym
) = 1;
18600 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18603 var_decode_location (attr
, sym
, cu
);
18605 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18608 dwarf2_const_value (attr
, sym
, cu
);
18611 list_to_add
= cu
->list_in_scope
;
18613 case DW_TAG_unspecified_parameters
:
18614 /* From varargs functions; gdb doesn't seem to have any
18615 interest in this information, so just ignore it for now.
18618 case DW_TAG_template_type_param
:
18620 /* Fall through. */
18621 case DW_TAG_class_type
:
18622 case DW_TAG_interface_type
:
18623 case DW_TAG_structure_type
:
18624 case DW_TAG_union_type
:
18625 case DW_TAG_set_type
:
18626 case DW_TAG_enumeration_type
:
18627 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18628 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
18631 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
18632 really ever be static objects: otherwise, if you try
18633 to, say, break of a class's method and you're in a file
18634 which doesn't mention that class, it won't work unless
18635 the check for all static symbols in lookup_symbol_aux
18636 saves you. See the OtherFileClass tests in
18637 gdb.c++/namespace.exp. */
18641 list_to_add
= (cu
->list_in_scope
== &file_symbols
18642 && cu
->language
== language_cplus
18643 ? &global_symbols
: cu
->list_in_scope
);
18645 /* The semantics of C++ state that "struct foo {
18646 ... }" also defines a typedef for "foo". */
18647 if (cu
->language
== language_cplus
18648 || cu
->language
== language_ada
18649 || cu
->language
== language_d
18650 || cu
->language
== language_rust
)
18652 /* The symbol's name is already allocated along
18653 with this objfile, so we don't need to
18654 duplicate it for the type. */
18655 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
18656 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
18661 case DW_TAG_typedef
:
18662 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18663 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18664 list_to_add
= cu
->list_in_scope
;
18666 case DW_TAG_base_type
:
18667 case DW_TAG_subrange_type
:
18668 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18669 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18670 list_to_add
= cu
->list_in_scope
;
18672 case DW_TAG_enumerator
:
18673 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18676 dwarf2_const_value (attr
, sym
, cu
);
18679 /* NOTE: carlton/2003-11-10: See comment above in the
18680 DW_TAG_class_type, etc. block. */
18682 list_to_add
= (cu
->list_in_scope
== &file_symbols
18683 && cu
->language
== language_cplus
18684 ? &global_symbols
: cu
->list_in_scope
);
18687 case DW_TAG_imported_declaration
:
18688 case DW_TAG_namespace
:
18689 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18690 list_to_add
= &global_symbols
;
18692 case DW_TAG_module
:
18693 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18694 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
18695 list_to_add
= &global_symbols
;
18697 case DW_TAG_common_block
:
18698 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
18699 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
18700 add_symbol_to_list (sym
, cu
->list_in_scope
);
18703 /* Not a tag we recognize. Hopefully we aren't processing
18704 trash data, but since we must specifically ignore things
18705 we don't recognize, there is nothing else we should do at
18707 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
18708 dwarf_tag_name (die
->tag
));
18714 sym
->hash_next
= objfile
->template_symbols
;
18715 objfile
->template_symbols
= sym
;
18716 list_to_add
= NULL
;
18719 if (list_to_add
!= NULL
)
18720 add_symbol_to_list (sym
, list_to_add
);
18722 /* For the benefit of old versions of GCC, check for anonymous
18723 namespaces based on the demangled name. */
18724 if (!cu
->processing_has_namespace_info
18725 && cu
->language
== language_cplus
)
18726 cp_scan_for_anonymous_namespaces (sym
, objfile
);
18731 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18733 static struct symbol
*
18734 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
18736 return new_symbol_full (die
, type
, cu
, NULL
);
18739 /* Given an attr with a DW_FORM_dataN value in host byte order,
18740 zero-extend it as appropriate for the symbol's type. The DWARF
18741 standard (v4) is not entirely clear about the meaning of using
18742 DW_FORM_dataN for a constant with a signed type, where the type is
18743 wider than the data. The conclusion of a discussion on the DWARF
18744 list was that this is unspecified. We choose to always zero-extend
18745 because that is the interpretation long in use by GCC. */
18748 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
18749 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
18751 struct objfile
*objfile
= cu
->objfile
;
18752 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
18753 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
18754 LONGEST l
= DW_UNSND (attr
);
18756 if (bits
< sizeof (*value
) * 8)
18758 l
&= ((LONGEST
) 1 << bits
) - 1;
18761 else if (bits
== sizeof (*value
) * 8)
18765 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
18766 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
18773 /* Read a constant value from an attribute. Either set *VALUE, or if
18774 the value does not fit in *VALUE, set *BYTES - either already
18775 allocated on the objfile obstack, or newly allocated on OBSTACK,
18776 or, set *BATON, if we translated the constant to a location
18780 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
18781 const char *name
, struct obstack
*obstack
,
18782 struct dwarf2_cu
*cu
,
18783 LONGEST
*value
, const gdb_byte
**bytes
,
18784 struct dwarf2_locexpr_baton
**baton
)
18786 struct objfile
*objfile
= cu
->objfile
;
18787 struct comp_unit_head
*cu_header
= &cu
->header
;
18788 struct dwarf_block
*blk
;
18789 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
18790 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
18796 switch (attr
->form
)
18799 case DW_FORM_GNU_addr_index
:
18803 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
18804 dwarf2_const_value_length_mismatch_complaint (name
,
18805 cu_header
->addr_size
,
18806 TYPE_LENGTH (type
));
18807 /* Symbols of this form are reasonably rare, so we just
18808 piggyback on the existing location code rather than writing
18809 a new implementation of symbol_computed_ops. */
18810 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
18811 (*baton
)->per_cu
= cu
->per_cu
;
18812 gdb_assert ((*baton
)->per_cu
);
18814 (*baton
)->size
= 2 + cu_header
->addr_size
;
18815 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
18816 (*baton
)->data
= data
;
18818 data
[0] = DW_OP_addr
;
18819 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
18820 byte_order
, DW_ADDR (attr
));
18821 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
18824 case DW_FORM_string
:
18826 case DW_FORM_GNU_str_index
:
18827 case DW_FORM_GNU_strp_alt
:
18828 /* DW_STRING is already allocated on the objfile obstack, point
18830 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
18832 case DW_FORM_block1
:
18833 case DW_FORM_block2
:
18834 case DW_FORM_block4
:
18835 case DW_FORM_block
:
18836 case DW_FORM_exprloc
:
18837 blk
= DW_BLOCK (attr
);
18838 if (TYPE_LENGTH (type
) != blk
->size
)
18839 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
18840 TYPE_LENGTH (type
));
18841 *bytes
= blk
->data
;
18844 /* The DW_AT_const_value attributes are supposed to carry the
18845 symbol's value "represented as it would be on the target
18846 architecture." By the time we get here, it's already been
18847 converted to host endianness, so we just need to sign- or
18848 zero-extend it as appropriate. */
18849 case DW_FORM_data1
:
18850 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
18852 case DW_FORM_data2
:
18853 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
18855 case DW_FORM_data4
:
18856 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
18858 case DW_FORM_data8
:
18859 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
18862 case DW_FORM_sdata
:
18863 *value
= DW_SND (attr
);
18866 case DW_FORM_udata
:
18867 *value
= DW_UNSND (attr
);
18871 complaint (&symfile_complaints
,
18872 _("unsupported const value attribute form: '%s'"),
18873 dwarf_form_name (attr
->form
));
18880 /* Copy constant value from an attribute to a symbol. */
18883 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
18884 struct dwarf2_cu
*cu
)
18886 struct objfile
*objfile
= cu
->objfile
;
18888 const gdb_byte
*bytes
;
18889 struct dwarf2_locexpr_baton
*baton
;
18891 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
18892 SYMBOL_PRINT_NAME (sym
),
18893 &objfile
->objfile_obstack
, cu
,
18894 &value
, &bytes
, &baton
);
18898 SYMBOL_LOCATION_BATON (sym
) = baton
;
18899 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
18901 else if (bytes
!= NULL
)
18903 SYMBOL_VALUE_BYTES (sym
) = bytes
;
18904 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
18908 SYMBOL_VALUE (sym
) = value
;
18909 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
18913 /* Return the type of the die in question using its DW_AT_type attribute. */
18915 static struct type
*
18916 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18918 struct attribute
*type_attr
;
18920 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
18923 /* A missing DW_AT_type represents a void type. */
18924 return objfile_type (cu
->objfile
)->builtin_void
;
18927 return lookup_die_type (die
, type_attr
, cu
);
18930 /* True iff CU's producer generates GNAT Ada auxiliary information
18931 that allows to find parallel types through that information instead
18932 of having to do expensive parallel lookups by type name. */
18935 need_gnat_info (struct dwarf2_cu
*cu
)
18937 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18938 of GNAT produces this auxiliary information, without any indication
18939 that it is produced. Part of enhancing the FSF version of GNAT
18940 to produce that information will be to put in place an indicator
18941 that we can use in order to determine whether the descriptive type
18942 info is available or not. One suggestion that has been made is
18943 to use a new attribute, attached to the CU die. For now, assume
18944 that the descriptive type info is not available. */
18948 /* Return the auxiliary type of the die in question using its
18949 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18950 attribute is not present. */
18952 static struct type
*
18953 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18955 struct attribute
*type_attr
;
18957 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
18961 return lookup_die_type (die
, type_attr
, cu
);
18964 /* If DIE has a descriptive_type attribute, then set the TYPE's
18965 descriptive type accordingly. */
18968 set_descriptive_type (struct type
*type
, struct die_info
*die
,
18969 struct dwarf2_cu
*cu
)
18971 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
18973 if (descriptive_type
)
18975 ALLOCATE_GNAT_AUX_TYPE (type
);
18976 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
18980 /* Return the containing type of the die in question using its
18981 DW_AT_containing_type attribute. */
18983 static struct type
*
18984 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18986 struct attribute
*type_attr
;
18988 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
18990 error (_("Dwarf Error: Problem turning containing type into gdb type "
18991 "[in module %s]"), objfile_name (cu
->objfile
));
18993 return lookup_die_type (die
, type_attr
, cu
);
18996 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18998 static struct type
*
18999 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
19001 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19002 char *message
, *saved
;
19004 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
19005 objfile_name (objfile
),
19006 cu
->header
.offset
.sect_off
,
19007 die
->offset
.sect_off
);
19008 saved
= (char *) obstack_copy0 (&objfile
->objfile_obstack
,
19009 message
, strlen (message
));
19012 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
19015 /* Look up the type of DIE in CU using its type attribute ATTR.
19016 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
19017 DW_AT_containing_type.
19018 If there is no type substitute an error marker. */
19020 static struct type
*
19021 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
19022 struct dwarf2_cu
*cu
)
19024 struct objfile
*objfile
= cu
->objfile
;
19025 struct type
*this_type
;
19027 gdb_assert (attr
->name
== DW_AT_type
19028 || attr
->name
== DW_AT_GNAT_descriptive_type
19029 || attr
->name
== DW_AT_containing_type
);
19031 /* First see if we have it cached. */
19033 if (attr
->form
== DW_FORM_GNU_ref_alt
)
19035 struct dwarf2_per_cu_data
*per_cu
;
19036 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
19038 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
19039 this_type
= get_die_type_at_offset (offset
, per_cu
);
19041 else if (attr_form_is_ref (attr
))
19043 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
19045 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
19047 else if (attr
->form
== DW_FORM_ref_sig8
)
19049 ULONGEST signature
= DW_SIGNATURE (attr
);
19051 return get_signatured_type (die
, signature
, cu
);
19055 complaint (&symfile_complaints
,
19056 _("Dwarf Error: Bad type attribute %s in DIE"
19057 " at 0x%x [in module %s]"),
19058 dwarf_attr_name (attr
->name
), die
->offset
.sect_off
,
19059 objfile_name (objfile
));
19060 return build_error_marker_type (cu
, die
);
19063 /* If not cached we need to read it in. */
19065 if (this_type
== NULL
)
19067 struct die_info
*type_die
= NULL
;
19068 struct dwarf2_cu
*type_cu
= cu
;
19070 if (attr_form_is_ref (attr
))
19071 type_die
= follow_die_ref (die
, attr
, &type_cu
);
19072 if (type_die
== NULL
)
19073 return build_error_marker_type (cu
, die
);
19074 /* If we find the type now, it's probably because the type came
19075 from an inter-CU reference and the type's CU got expanded before
19077 this_type
= read_type_die (type_die
, type_cu
);
19080 /* If we still don't have a type use an error marker. */
19082 if (this_type
== NULL
)
19083 return build_error_marker_type (cu
, die
);
19088 /* Return the type in DIE, CU.
19089 Returns NULL for invalid types.
19091 This first does a lookup in die_type_hash,
19092 and only reads the die in if necessary.
19094 NOTE: This can be called when reading in partial or full symbols. */
19096 static struct type
*
19097 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
19099 struct type
*this_type
;
19101 this_type
= get_die_type (die
, cu
);
19105 return read_type_die_1 (die
, cu
);
19108 /* Read the type in DIE, CU.
19109 Returns NULL for invalid types. */
19111 static struct type
*
19112 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
19114 struct type
*this_type
= NULL
;
19118 case DW_TAG_class_type
:
19119 case DW_TAG_interface_type
:
19120 case DW_TAG_structure_type
:
19121 case DW_TAG_union_type
:
19122 this_type
= read_structure_type (die
, cu
);
19124 case DW_TAG_enumeration_type
:
19125 this_type
= read_enumeration_type (die
, cu
);
19127 case DW_TAG_subprogram
:
19128 case DW_TAG_subroutine_type
:
19129 case DW_TAG_inlined_subroutine
:
19130 this_type
= read_subroutine_type (die
, cu
);
19132 case DW_TAG_array_type
:
19133 this_type
= read_array_type (die
, cu
);
19135 case DW_TAG_set_type
:
19136 this_type
= read_set_type (die
, cu
);
19138 case DW_TAG_pointer_type
:
19139 this_type
= read_tag_pointer_type (die
, cu
);
19141 case DW_TAG_ptr_to_member_type
:
19142 this_type
= read_tag_ptr_to_member_type (die
, cu
);
19144 case DW_TAG_reference_type
:
19145 this_type
= read_tag_reference_type (die
, cu
);
19147 case DW_TAG_const_type
:
19148 this_type
= read_tag_const_type (die
, cu
);
19150 case DW_TAG_volatile_type
:
19151 this_type
= read_tag_volatile_type (die
, cu
);
19153 case DW_TAG_restrict_type
:
19154 this_type
= read_tag_restrict_type (die
, cu
);
19156 case DW_TAG_string_type
:
19157 this_type
= read_tag_string_type (die
, cu
);
19159 case DW_TAG_typedef
:
19160 this_type
= read_typedef (die
, cu
);
19162 case DW_TAG_subrange_type
:
19163 this_type
= read_subrange_type (die
, cu
);
19165 case DW_TAG_base_type
:
19166 this_type
= read_base_type (die
, cu
);
19168 case DW_TAG_unspecified_type
:
19169 this_type
= read_unspecified_type (die
, cu
);
19171 case DW_TAG_namespace
:
19172 this_type
= read_namespace_type (die
, cu
);
19174 case DW_TAG_module
:
19175 this_type
= read_module_type (die
, cu
);
19177 case DW_TAG_atomic_type
:
19178 this_type
= read_tag_atomic_type (die
, cu
);
19181 complaint (&symfile_complaints
,
19182 _("unexpected tag in read_type_die: '%s'"),
19183 dwarf_tag_name (die
->tag
));
19190 /* See if we can figure out if the class lives in a namespace. We do
19191 this by looking for a member function; its demangled name will
19192 contain namespace info, if there is any.
19193 Return the computed name or NULL.
19194 Space for the result is allocated on the objfile's obstack.
19195 This is the full-die version of guess_partial_die_structure_name.
19196 In this case we know DIE has no useful parent. */
19199 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19201 struct die_info
*spec_die
;
19202 struct dwarf2_cu
*spec_cu
;
19203 struct die_info
*child
;
19206 spec_die
= die_specification (die
, &spec_cu
);
19207 if (spec_die
!= NULL
)
19213 for (child
= die
->child
;
19215 child
= child
->sibling
)
19217 if (child
->tag
== DW_TAG_subprogram
)
19219 const char *linkage_name
;
19221 linkage_name
= dwarf2_string_attr (child
, DW_AT_linkage_name
, cu
);
19222 if (linkage_name
== NULL
)
19223 linkage_name
= dwarf2_string_attr (child
, DW_AT_MIPS_linkage_name
,
19225 if (linkage_name
!= NULL
)
19228 = language_class_name_from_physname (cu
->language_defn
,
19232 if (actual_name
!= NULL
)
19234 const char *die_name
= dwarf2_name (die
, cu
);
19236 if (die_name
!= NULL
19237 && strcmp (die_name
, actual_name
) != 0)
19239 /* Strip off the class name from the full name.
19240 We want the prefix. */
19241 int die_name_len
= strlen (die_name
);
19242 int actual_name_len
= strlen (actual_name
);
19244 /* Test for '::' as a sanity check. */
19245 if (actual_name_len
> die_name_len
+ 2
19246 && actual_name
[actual_name_len
19247 - die_name_len
- 1] == ':')
19248 name
= (char *) obstack_copy0 (
19249 &cu
->objfile
->per_bfd
->storage_obstack
,
19250 actual_name
, actual_name_len
- die_name_len
- 2);
19253 xfree (actual_name
);
19262 /* GCC might emit a nameless typedef that has a linkage name. Determine the
19263 prefix part in such case. See
19264 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19267 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19269 struct attribute
*attr
;
19272 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
19273 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
19276 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
19279 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19281 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19282 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19285 /* dwarf2_name had to be already called. */
19286 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
19288 /* Strip the base name, keep any leading namespaces/classes. */
19289 base
= strrchr (DW_STRING (attr
), ':');
19290 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
19293 return (char *) obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19295 &base
[-1] - DW_STRING (attr
));
19298 /* Return the name of the namespace/class that DIE is defined within,
19299 or "" if we can't tell. The caller should not xfree the result.
19301 For example, if we're within the method foo() in the following
19311 then determine_prefix on foo's die will return "N::C". */
19313 static const char *
19314 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19316 struct die_info
*parent
, *spec_die
;
19317 struct dwarf2_cu
*spec_cu
;
19318 struct type
*parent_type
;
19321 if (cu
->language
!= language_cplus
19322 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
19323 && cu
->language
!= language_rust
)
19326 retval
= anonymous_struct_prefix (die
, cu
);
19330 /* We have to be careful in the presence of DW_AT_specification.
19331 For example, with GCC 3.4, given the code
19335 // Definition of N::foo.
19339 then we'll have a tree of DIEs like this:
19341 1: DW_TAG_compile_unit
19342 2: DW_TAG_namespace // N
19343 3: DW_TAG_subprogram // declaration of N::foo
19344 4: DW_TAG_subprogram // definition of N::foo
19345 DW_AT_specification // refers to die #3
19347 Thus, when processing die #4, we have to pretend that we're in
19348 the context of its DW_AT_specification, namely the contex of die
19351 spec_die
= die_specification (die
, &spec_cu
);
19352 if (spec_die
== NULL
)
19353 parent
= die
->parent
;
19356 parent
= spec_die
->parent
;
19360 if (parent
== NULL
)
19362 else if (parent
->building_fullname
)
19365 const char *parent_name
;
19367 /* It has been seen on RealView 2.2 built binaries,
19368 DW_TAG_template_type_param types actually _defined_ as
19369 children of the parent class:
19372 template class <class Enum> Class{};
19373 Class<enum E> class_e;
19375 1: DW_TAG_class_type (Class)
19376 2: DW_TAG_enumeration_type (E)
19377 3: DW_TAG_enumerator (enum1:0)
19378 3: DW_TAG_enumerator (enum2:1)
19380 2: DW_TAG_template_type_param
19381 DW_AT_type DW_FORM_ref_udata (E)
19383 Besides being broken debug info, it can put GDB into an
19384 infinite loop. Consider:
19386 When we're building the full name for Class<E>, we'll start
19387 at Class, and go look over its template type parameters,
19388 finding E. We'll then try to build the full name of E, and
19389 reach here. We're now trying to build the full name of E,
19390 and look over the parent DIE for containing scope. In the
19391 broken case, if we followed the parent DIE of E, we'd again
19392 find Class, and once again go look at its template type
19393 arguments, etc., etc. Simply don't consider such parent die
19394 as source-level parent of this die (it can't be, the language
19395 doesn't allow it), and break the loop here. */
19396 name
= dwarf2_name (die
, cu
);
19397 parent_name
= dwarf2_name (parent
, cu
);
19398 complaint (&symfile_complaints
,
19399 _("template param type '%s' defined within parent '%s'"),
19400 name
? name
: "<unknown>",
19401 parent_name
? parent_name
: "<unknown>");
19405 switch (parent
->tag
)
19407 case DW_TAG_namespace
:
19408 parent_type
= read_type_die (parent
, cu
);
19409 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
19410 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
19411 Work around this problem here. */
19412 if (cu
->language
== language_cplus
19413 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
19415 /* We give a name to even anonymous namespaces. */
19416 return TYPE_TAG_NAME (parent_type
);
19417 case DW_TAG_class_type
:
19418 case DW_TAG_interface_type
:
19419 case DW_TAG_structure_type
:
19420 case DW_TAG_union_type
:
19421 case DW_TAG_module
:
19422 parent_type
= read_type_die (parent
, cu
);
19423 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19424 return TYPE_TAG_NAME (parent_type
);
19426 /* An anonymous structure is only allowed non-static data
19427 members; no typedefs, no member functions, et cetera.
19428 So it does not need a prefix. */
19430 case DW_TAG_compile_unit
:
19431 case DW_TAG_partial_unit
:
19432 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
19433 if (cu
->language
== language_cplus
19434 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
19435 && die
->child
!= NULL
19436 && (die
->tag
== DW_TAG_class_type
19437 || die
->tag
== DW_TAG_structure_type
19438 || die
->tag
== DW_TAG_union_type
))
19440 char *name
= guess_full_die_structure_name (die
, cu
);
19445 case DW_TAG_enumeration_type
:
19446 parent_type
= read_type_die (parent
, cu
);
19447 if (TYPE_DECLARED_CLASS (parent_type
))
19449 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19450 return TYPE_TAG_NAME (parent_type
);
19453 /* Fall through. */
19455 return determine_prefix (parent
, cu
);
19459 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
19460 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
19461 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
19462 an obconcat, otherwise allocate storage for the result. The CU argument is
19463 used to determine the language and hence, the appropriate separator. */
19465 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
19468 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
19469 int physname
, struct dwarf2_cu
*cu
)
19471 const char *lead
= "";
19474 if (suffix
== NULL
|| suffix
[0] == '\0'
19475 || prefix
== NULL
|| prefix
[0] == '\0')
19477 else if (cu
->language
== language_d
)
19479 /* For D, the 'main' function could be defined in any module, but it
19480 should never be prefixed. */
19481 if (strcmp (suffix
, "D main") == 0)
19489 else if (cu
->language
== language_fortran
&& physname
)
19491 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
19492 DW_AT_MIPS_linkage_name is preferred and used instead. */
19500 if (prefix
== NULL
)
19502 if (suffix
== NULL
)
19509 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
19511 strcpy (retval
, lead
);
19512 strcat (retval
, prefix
);
19513 strcat (retval
, sep
);
19514 strcat (retval
, suffix
);
19519 /* We have an obstack. */
19520 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
19524 /* Return sibling of die, NULL if no sibling. */
19526 static struct die_info
*
19527 sibling_die (struct die_info
*die
)
19529 return die
->sibling
;
19532 /* Get name of a die, return NULL if not found. */
19534 static const char *
19535 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
19536 struct obstack
*obstack
)
19538 if (name
&& cu
->language
== language_cplus
)
19540 std::string canon_name
= cp_canonicalize_string (name
);
19542 if (!canon_name
.empty ())
19544 if (canon_name
!= name
)
19545 name
= (const char *) obstack_copy0 (obstack
,
19546 canon_name
.c_str (),
19547 canon_name
.length ());
19554 /* Get name of a die, return NULL if not found.
19555 Anonymous namespaces are converted to their magic string. */
19557 static const char *
19558 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19560 struct attribute
*attr
;
19562 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19563 if ((!attr
|| !DW_STRING (attr
))
19564 && die
->tag
!= DW_TAG_namespace
19565 && die
->tag
!= DW_TAG_class_type
19566 && die
->tag
!= DW_TAG_interface_type
19567 && die
->tag
!= DW_TAG_structure_type
19568 && die
->tag
!= DW_TAG_union_type
)
19573 case DW_TAG_compile_unit
:
19574 case DW_TAG_partial_unit
:
19575 /* Compilation units have a DW_AT_name that is a filename, not
19576 a source language identifier. */
19577 case DW_TAG_enumeration_type
:
19578 case DW_TAG_enumerator
:
19579 /* These tags always have simple identifiers already; no need
19580 to canonicalize them. */
19581 return DW_STRING (attr
);
19583 case DW_TAG_namespace
:
19584 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19585 return DW_STRING (attr
);
19586 return CP_ANONYMOUS_NAMESPACE_STR
;
19588 case DW_TAG_class_type
:
19589 case DW_TAG_interface_type
:
19590 case DW_TAG_structure_type
:
19591 case DW_TAG_union_type
:
19592 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19593 structures or unions. These were of the form "._%d" in GCC 4.1,
19594 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19595 and GCC 4.4. We work around this problem by ignoring these. */
19596 if (attr
&& DW_STRING (attr
)
19597 && (startswith (DW_STRING (attr
), "._")
19598 || startswith (DW_STRING (attr
), "<anonymous")))
19601 /* GCC might emit a nameless typedef that has a linkage name. See
19602 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19603 if (!attr
|| DW_STRING (attr
) == NULL
)
19605 char *demangled
= NULL
;
19607 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19609 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19611 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19614 /* Avoid demangling DW_STRING (attr) the second time on a second
19615 call for the same DIE. */
19616 if (!DW_STRING_IS_CANONICAL (attr
))
19617 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
19623 /* FIXME: we already did this for the partial symbol... */
19626 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19627 demangled
, strlen (demangled
)));
19628 DW_STRING_IS_CANONICAL (attr
) = 1;
19631 /* Strip any leading namespaces/classes, keep only the base name.
19632 DW_AT_name for named DIEs does not contain the prefixes. */
19633 base
= strrchr (DW_STRING (attr
), ':');
19634 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
19637 return DW_STRING (attr
);
19646 if (!DW_STRING_IS_CANONICAL (attr
))
19649 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
19650 &cu
->objfile
->per_bfd
->storage_obstack
);
19651 DW_STRING_IS_CANONICAL (attr
) = 1;
19653 return DW_STRING (attr
);
19656 /* Return the die that this die in an extension of, or NULL if there
19657 is none. *EXT_CU is the CU containing DIE on input, and the CU
19658 containing the return value on output. */
19660 static struct die_info
*
19661 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
19663 struct attribute
*attr
;
19665 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
19669 return follow_die_ref (die
, attr
, ext_cu
);
19672 /* Convert a DIE tag into its string name. */
19674 static const char *
19675 dwarf_tag_name (unsigned tag
)
19677 const char *name
= get_DW_TAG_name (tag
);
19680 return "DW_TAG_<unknown>";
19685 /* Convert a DWARF attribute code into its string name. */
19687 static const char *
19688 dwarf_attr_name (unsigned attr
)
19692 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19693 if (attr
== DW_AT_MIPS_fde
)
19694 return "DW_AT_MIPS_fde";
19696 if (attr
== DW_AT_HP_block_index
)
19697 return "DW_AT_HP_block_index";
19700 name
= get_DW_AT_name (attr
);
19703 return "DW_AT_<unknown>";
19708 /* Convert a DWARF value form code into its string name. */
19710 static const char *
19711 dwarf_form_name (unsigned form
)
19713 const char *name
= get_DW_FORM_name (form
);
19716 return "DW_FORM_<unknown>";
19722 dwarf_bool_name (unsigned mybool
)
19730 /* Convert a DWARF type code into its string name. */
19732 static const char *
19733 dwarf_type_encoding_name (unsigned enc
)
19735 const char *name
= get_DW_ATE_name (enc
);
19738 return "DW_ATE_<unknown>";
19744 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
19748 print_spaces (indent
, f
);
19749 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
19750 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
19752 if (die
->parent
!= NULL
)
19754 print_spaces (indent
, f
);
19755 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
19756 die
->parent
->offset
.sect_off
);
19759 print_spaces (indent
, f
);
19760 fprintf_unfiltered (f
, " has children: %s\n",
19761 dwarf_bool_name (die
->child
!= NULL
));
19763 print_spaces (indent
, f
);
19764 fprintf_unfiltered (f
, " attributes:\n");
19766 for (i
= 0; i
< die
->num_attrs
; ++i
)
19768 print_spaces (indent
, f
);
19769 fprintf_unfiltered (f
, " %s (%s) ",
19770 dwarf_attr_name (die
->attrs
[i
].name
),
19771 dwarf_form_name (die
->attrs
[i
].form
));
19773 switch (die
->attrs
[i
].form
)
19776 case DW_FORM_GNU_addr_index
:
19777 fprintf_unfiltered (f
, "address: ");
19778 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
19780 case DW_FORM_block2
:
19781 case DW_FORM_block4
:
19782 case DW_FORM_block
:
19783 case DW_FORM_block1
:
19784 fprintf_unfiltered (f
, "block: size %s",
19785 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19787 case DW_FORM_exprloc
:
19788 fprintf_unfiltered (f
, "expression: size %s",
19789 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19791 case DW_FORM_ref_addr
:
19792 fprintf_unfiltered (f
, "ref address: ");
19793 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19795 case DW_FORM_GNU_ref_alt
:
19796 fprintf_unfiltered (f
, "alt ref address: ");
19797 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19803 case DW_FORM_ref_udata
:
19804 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
19805 (long) (DW_UNSND (&die
->attrs
[i
])));
19807 case DW_FORM_data1
:
19808 case DW_FORM_data2
:
19809 case DW_FORM_data4
:
19810 case DW_FORM_data8
:
19811 case DW_FORM_udata
:
19812 case DW_FORM_sdata
:
19813 fprintf_unfiltered (f
, "constant: %s",
19814 pulongest (DW_UNSND (&die
->attrs
[i
])));
19816 case DW_FORM_sec_offset
:
19817 fprintf_unfiltered (f
, "section offset: %s",
19818 pulongest (DW_UNSND (&die
->attrs
[i
])));
19820 case DW_FORM_ref_sig8
:
19821 fprintf_unfiltered (f
, "signature: %s",
19822 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
19824 case DW_FORM_string
:
19826 case DW_FORM_GNU_str_index
:
19827 case DW_FORM_GNU_strp_alt
:
19828 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
19829 DW_STRING (&die
->attrs
[i
])
19830 ? DW_STRING (&die
->attrs
[i
]) : "",
19831 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
19834 if (DW_UNSND (&die
->attrs
[i
]))
19835 fprintf_unfiltered (f
, "flag: TRUE");
19837 fprintf_unfiltered (f
, "flag: FALSE");
19839 case DW_FORM_flag_present
:
19840 fprintf_unfiltered (f
, "flag: TRUE");
19842 case DW_FORM_indirect
:
19843 /* The reader will have reduced the indirect form to
19844 the "base form" so this form should not occur. */
19845 fprintf_unfiltered (f
,
19846 "unexpected attribute form: DW_FORM_indirect");
19849 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
19850 die
->attrs
[i
].form
);
19853 fprintf_unfiltered (f
, "\n");
19858 dump_die_for_error (struct die_info
*die
)
19860 dump_die_shallow (gdb_stderr
, 0, die
);
19864 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
19866 int indent
= level
* 4;
19868 gdb_assert (die
!= NULL
);
19870 if (level
>= max_level
)
19873 dump_die_shallow (f
, indent
, die
);
19875 if (die
->child
!= NULL
)
19877 print_spaces (indent
, f
);
19878 fprintf_unfiltered (f
, " Children:");
19879 if (level
+ 1 < max_level
)
19881 fprintf_unfiltered (f
, "\n");
19882 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
19886 fprintf_unfiltered (f
,
19887 " [not printed, max nesting level reached]\n");
19891 if (die
->sibling
!= NULL
&& level
> 0)
19893 dump_die_1 (f
, level
, max_level
, die
->sibling
);
19897 /* This is called from the pdie macro in gdbinit.in.
19898 It's not static so gcc will keep a copy callable from gdb. */
19901 dump_die (struct die_info
*die
, int max_level
)
19903 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
19907 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
19911 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
19917 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19921 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
19923 sect_offset retval
= { DW_UNSND (attr
) };
19925 if (attr_form_is_ref (attr
))
19928 retval
.sect_off
= 0;
19929 complaint (&symfile_complaints
,
19930 _("unsupported die ref attribute form: '%s'"),
19931 dwarf_form_name (attr
->form
));
19935 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19936 * the value held by the attribute is not constant. */
19939 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
19941 if (attr
->form
== DW_FORM_sdata
)
19942 return DW_SND (attr
);
19943 else if (attr
->form
== DW_FORM_udata
19944 || attr
->form
== DW_FORM_data1
19945 || attr
->form
== DW_FORM_data2
19946 || attr
->form
== DW_FORM_data4
19947 || attr
->form
== DW_FORM_data8
)
19948 return DW_UNSND (attr
);
19951 complaint (&symfile_complaints
,
19952 _("Attribute value is not a constant (%s)"),
19953 dwarf_form_name (attr
->form
));
19954 return default_value
;
19958 /* Follow reference or signature attribute ATTR of SRC_DIE.
19959 On entry *REF_CU is the CU of SRC_DIE.
19960 On exit *REF_CU is the CU of the result. */
19962 static struct die_info
*
19963 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
19964 struct dwarf2_cu
**ref_cu
)
19966 struct die_info
*die
;
19968 if (attr_form_is_ref (attr
))
19969 die
= follow_die_ref (src_die
, attr
, ref_cu
);
19970 else if (attr
->form
== DW_FORM_ref_sig8
)
19971 die
= follow_die_sig (src_die
, attr
, ref_cu
);
19974 dump_die_for_error (src_die
);
19975 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19976 objfile_name ((*ref_cu
)->objfile
));
19982 /* Follow reference OFFSET.
19983 On entry *REF_CU is the CU of the source die referencing OFFSET.
19984 On exit *REF_CU is the CU of the result.
19985 Returns NULL if OFFSET is invalid. */
19987 static struct die_info
*
19988 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
19989 struct dwarf2_cu
**ref_cu
)
19991 struct die_info temp_die
;
19992 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
19994 gdb_assert (cu
->per_cu
!= NULL
);
19998 if (cu
->per_cu
->is_debug_types
)
20000 /* .debug_types CUs cannot reference anything outside their CU.
20001 If they need to, they have to reference a signatured type via
20002 DW_FORM_ref_sig8. */
20003 if (! offset_in_cu_p (&cu
->header
, offset
))
20006 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
20007 || ! offset_in_cu_p (&cu
->header
, offset
))
20009 struct dwarf2_per_cu_data
*per_cu
;
20011 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
20014 /* If necessary, add it to the queue and load its DIEs. */
20015 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
20016 load_full_comp_unit (per_cu
, cu
->language
);
20018 target_cu
= per_cu
->cu
;
20020 else if (cu
->dies
== NULL
)
20022 /* We're loading full DIEs during partial symbol reading. */
20023 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
20024 load_full_comp_unit (cu
->per_cu
, language_minimal
);
20027 *ref_cu
= target_cu
;
20028 temp_die
.offset
= offset
;
20029 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
20030 &temp_die
, offset
.sect_off
);
20033 /* Follow reference attribute ATTR of SRC_DIE.
20034 On entry *REF_CU is the CU of SRC_DIE.
20035 On exit *REF_CU is the CU of the result. */
20037 static struct die_info
*
20038 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
20039 struct dwarf2_cu
**ref_cu
)
20041 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
20042 struct dwarf2_cu
*cu
= *ref_cu
;
20043 struct die_info
*die
;
20045 die
= follow_die_offset (offset
,
20046 (attr
->form
== DW_FORM_GNU_ref_alt
20047 || cu
->per_cu
->is_dwz
),
20050 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
20051 "at 0x%x [in module %s]"),
20052 offset
.sect_off
, src_die
->offset
.sect_off
,
20053 objfile_name (cu
->objfile
));
20058 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
20059 Returned value is intended for DW_OP_call*. Returned
20060 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
20062 struct dwarf2_locexpr_baton
20063 dwarf2_fetch_die_loc_sect_off (sect_offset offset
,
20064 struct dwarf2_per_cu_data
*per_cu
,
20065 CORE_ADDR (*get_frame_pc
) (void *baton
),
20068 struct dwarf2_cu
*cu
;
20069 struct die_info
*die
;
20070 struct attribute
*attr
;
20071 struct dwarf2_locexpr_baton retval
;
20073 dw2_setup (per_cu
->objfile
);
20075 if (per_cu
->cu
== NULL
)
20080 /* We shouldn't get here for a dummy CU, but don't crash on the user.
20081 Instead just throw an error, not much else we can do. */
20082 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
20083 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20086 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20088 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20089 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20091 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20094 /* DWARF: "If there is no such attribute, then there is no effect.".
20095 DATA is ignored if SIZE is 0. */
20097 retval
.data
= NULL
;
20100 else if (attr_form_is_section_offset (attr
))
20102 struct dwarf2_loclist_baton loclist_baton
;
20103 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
20106 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
20108 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
20110 retval
.size
= size
;
20114 if (!attr_form_is_block (attr
))
20115 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
20116 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
20117 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20119 retval
.data
= DW_BLOCK (attr
)->data
;
20120 retval
.size
= DW_BLOCK (attr
)->size
;
20122 retval
.per_cu
= cu
->per_cu
;
20124 age_cached_comp_units ();
20129 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
20132 struct dwarf2_locexpr_baton
20133 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
20134 struct dwarf2_per_cu_data
*per_cu
,
20135 CORE_ADDR (*get_frame_pc
) (void *baton
),
20138 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
20140 return dwarf2_fetch_die_loc_sect_off (offset
, per_cu
, get_frame_pc
, baton
);
20143 /* Write a constant of a given type as target-ordered bytes into
20146 static const gdb_byte
*
20147 write_constant_as_bytes (struct obstack
*obstack
,
20148 enum bfd_endian byte_order
,
20155 *len
= TYPE_LENGTH (type
);
20156 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
20157 store_unsigned_integer (result
, *len
, byte_order
, value
);
20162 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
20163 pointer to the constant bytes and set LEN to the length of the
20164 data. If memory is needed, allocate it on OBSTACK. If the DIE
20165 does not have a DW_AT_const_value, return NULL. */
20168 dwarf2_fetch_constant_bytes (sect_offset offset
,
20169 struct dwarf2_per_cu_data
*per_cu
,
20170 struct obstack
*obstack
,
20173 struct dwarf2_cu
*cu
;
20174 struct die_info
*die
;
20175 struct attribute
*attr
;
20176 const gdb_byte
*result
= NULL
;
20179 enum bfd_endian byte_order
;
20181 dw2_setup (per_cu
->objfile
);
20183 if (per_cu
->cu
== NULL
)
20188 /* We shouldn't get here for a dummy CU, but don't crash on the user.
20189 Instead just throw an error, not much else we can do. */
20190 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
20191 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20194 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20196 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20197 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20200 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20204 byte_order
= (bfd_big_endian (per_cu
->objfile
->obfd
)
20205 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
20207 switch (attr
->form
)
20210 case DW_FORM_GNU_addr_index
:
20214 *len
= cu
->header
.addr_size
;
20215 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
20216 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
20220 case DW_FORM_string
:
20222 case DW_FORM_GNU_str_index
:
20223 case DW_FORM_GNU_strp_alt
:
20224 /* DW_STRING is already allocated on the objfile obstack, point
20226 result
= (const gdb_byte
*) DW_STRING (attr
);
20227 *len
= strlen (DW_STRING (attr
));
20229 case DW_FORM_block1
:
20230 case DW_FORM_block2
:
20231 case DW_FORM_block4
:
20232 case DW_FORM_block
:
20233 case DW_FORM_exprloc
:
20234 result
= DW_BLOCK (attr
)->data
;
20235 *len
= DW_BLOCK (attr
)->size
;
20238 /* The DW_AT_const_value attributes are supposed to carry the
20239 symbol's value "represented as it would be on the target
20240 architecture." By the time we get here, it's already been
20241 converted to host endianness, so we just need to sign- or
20242 zero-extend it as appropriate. */
20243 case DW_FORM_data1
:
20244 type
= die_type (die
, cu
);
20245 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
20246 if (result
== NULL
)
20247 result
= write_constant_as_bytes (obstack
, byte_order
,
20250 case DW_FORM_data2
:
20251 type
= die_type (die
, cu
);
20252 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
20253 if (result
== NULL
)
20254 result
= write_constant_as_bytes (obstack
, byte_order
,
20257 case DW_FORM_data4
:
20258 type
= die_type (die
, cu
);
20259 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
20260 if (result
== NULL
)
20261 result
= write_constant_as_bytes (obstack
, byte_order
,
20264 case DW_FORM_data8
:
20265 type
= die_type (die
, cu
);
20266 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
20267 if (result
== NULL
)
20268 result
= write_constant_as_bytes (obstack
, byte_order
,
20272 case DW_FORM_sdata
:
20273 type
= die_type (die
, cu
);
20274 result
= write_constant_as_bytes (obstack
, byte_order
,
20275 type
, DW_SND (attr
), len
);
20278 case DW_FORM_udata
:
20279 type
= die_type (die
, cu
);
20280 result
= write_constant_as_bytes (obstack
, byte_order
,
20281 type
, DW_UNSND (attr
), len
);
20285 complaint (&symfile_complaints
,
20286 _("unsupported const value attribute form: '%s'"),
20287 dwarf_form_name (attr
->form
));
20294 /* Return the type of the DIE at DIE_OFFSET in the CU named by
20298 dwarf2_get_die_type (cu_offset die_offset
,
20299 struct dwarf2_per_cu_data
*per_cu
)
20301 sect_offset die_offset_sect
;
20303 dw2_setup (per_cu
->objfile
);
20305 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
20306 return get_die_type_at_offset (die_offset_sect
, per_cu
);
20309 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
20310 On entry *REF_CU is the CU of SRC_DIE.
20311 On exit *REF_CU is the CU of the result.
20312 Returns NULL if the referenced DIE isn't found. */
20314 static struct die_info
*
20315 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
20316 struct dwarf2_cu
**ref_cu
)
20318 struct die_info temp_die
;
20319 struct dwarf2_cu
*sig_cu
;
20320 struct die_info
*die
;
20322 /* While it might be nice to assert sig_type->type == NULL here,
20323 we can get here for DW_AT_imported_declaration where we need
20324 the DIE not the type. */
20326 /* If necessary, add it to the queue and load its DIEs. */
20328 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
20329 read_signatured_type (sig_type
);
20331 sig_cu
= sig_type
->per_cu
.cu
;
20332 gdb_assert (sig_cu
!= NULL
);
20333 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
20334 temp_die
.offset
= sig_type
->type_offset_in_section
;
20335 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
20336 temp_die
.offset
.sect_off
);
20339 /* For .gdb_index version 7 keep track of included TUs.
20340 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
20341 if (dwarf2_per_objfile
->index_table
!= NULL
20342 && dwarf2_per_objfile
->index_table
->version
<= 7)
20344 VEC_safe_push (dwarf2_per_cu_ptr
,
20345 (*ref_cu
)->per_cu
->imported_symtabs
,
20356 /* Follow signatured type referenced by ATTR in SRC_DIE.
20357 On entry *REF_CU is the CU of SRC_DIE.
20358 On exit *REF_CU is the CU of the result.
20359 The result is the DIE of the type.
20360 If the referenced type cannot be found an error is thrown. */
20362 static struct die_info
*
20363 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
20364 struct dwarf2_cu
**ref_cu
)
20366 ULONGEST signature
= DW_SIGNATURE (attr
);
20367 struct signatured_type
*sig_type
;
20368 struct die_info
*die
;
20370 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
20372 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
20373 /* sig_type will be NULL if the signatured type is missing from
20375 if (sig_type
== NULL
)
20377 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
20378 " from DIE at 0x%x [in module %s]"),
20379 hex_string (signature
), src_die
->offset
.sect_off
,
20380 objfile_name ((*ref_cu
)->objfile
));
20383 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
20386 dump_die_for_error (src_die
);
20387 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
20388 " from DIE at 0x%x [in module %s]"),
20389 hex_string (signature
), src_die
->offset
.sect_off
,
20390 objfile_name ((*ref_cu
)->objfile
));
20396 /* Get the type specified by SIGNATURE referenced in DIE/CU,
20397 reading in and processing the type unit if necessary. */
20399 static struct type
*
20400 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
20401 struct dwarf2_cu
*cu
)
20403 struct signatured_type
*sig_type
;
20404 struct dwarf2_cu
*type_cu
;
20405 struct die_info
*type_die
;
20408 sig_type
= lookup_signatured_type (cu
, signature
);
20409 /* sig_type will be NULL if the signatured type is missing from
20411 if (sig_type
== NULL
)
20413 complaint (&symfile_complaints
,
20414 _("Dwarf Error: Cannot find signatured DIE %s referenced"
20415 " from DIE at 0x%x [in module %s]"),
20416 hex_string (signature
), die
->offset
.sect_off
,
20417 objfile_name (dwarf2_per_objfile
->objfile
));
20418 return build_error_marker_type (cu
, die
);
20421 /* If we already know the type we're done. */
20422 if (sig_type
->type
!= NULL
)
20423 return sig_type
->type
;
20426 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
20427 if (type_die
!= NULL
)
20429 /* N.B. We need to call get_die_type to ensure only one type for this DIE
20430 is created. This is important, for example, because for c++ classes
20431 we need TYPE_NAME set which is only done by new_symbol. Blech. */
20432 type
= read_type_die (type_die
, type_cu
);
20435 complaint (&symfile_complaints
,
20436 _("Dwarf Error: Cannot build signatured type %s"
20437 " referenced from DIE at 0x%x [in module %s]"),
20438 hex_string (signature
), die
->offset
.sect_off
,
20439 objfile_name (dwarf2_per_objfile
->objfile
));
20440 type
= build_error_marker_type (cu
, die
);
20445 complaint (&symfile_complaints
,
20446 _("Dwarf Error: Problem reading signatured DIE %s referenced"
20447 " from DIE at 0x%x [in module %s]"),
20448 hex_string (signature
), die
->offset
.sect_off
,
20449 objfile_name (dwarf2_per_objfile
->objfile
));
20450 type
= build_error_marker_type (cu
, die
);
20452 sig_type
->type
= type
;
20457 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
20458 reading in and processing the type unit if necessary. */
20460 static struct type
*
20461 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
20462 struct dwarf2_cu
*cu
) /* ARI: editCase function */
20464 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
20465 if (attr_form_is_ref (attr
))
20467 struct dwarf2_cu
*type_cu
= cu
;
20468 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
20470 return read_type_die (type_die
, type_cu
);
20472 else if (attr
->form
== DW_FORM_ref_sig8
)
20474 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
20478 complaint (&symfile_complaints
,
20479 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
20480 " at 0x%x [in module %s]"),
20481 dwarf_form_name (attr
->form
), die
->offset
.sect_off
,
20482 objfile_name (dwarf2_per_objfile
->objfile
));
20483 return build_error_marker_type (cu
, die
);
20487 /* Load the DIEs associated with type unit PER_CU into memory. */
20490 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
20492 struct signatured_type
*sig_type
;
20494 /* Caller is responsible for ensuring type_unit_groups don't get here. */
20495 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
20497 /* We have the per_cu, but we need the signatured_type.
20498 Fortunately this is an easy translation. */
20499 gdb_assert (per_cu
->is_debug_types
);
20500 sig_type
= (struct signatured_type
*) per_cu
;
20502 gdb_assert (per_cu
->cu
== NULL
);
20504 read_signatured_type (sig_type
);
20506 gdb_assert (per_cu
->cu
!= NULL
);
20509 /* die_reader_func for read_signatured_type.
20510 This is identical to load_full_comp_unit_reader,
20511 but is kept separate for now. */
20514 read_signatured_type_reader (const struct die_reader_specs
*reader
,
20515 const gdb_byte
*info_ptr
,
20516 struct die_info
*comp_unit_die
,
20520 struct dwarf2_cu
*cu
= reader
->cu
;
20522 gdb_assert (cu
->die_hash
== NULL
);
20524 htab_create_alloc_ex (cu
->header
.length
/ 12,
20528 &cu
->comp_unit_obstack
,
20529 hashtab_obstack_allocate
,
20530 dummy_obstack_deallocate
);
20533 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
20534 &info_ptr
, comp_unit_die
);
20535 cu
->dies
= comp_unit_die
;
20536 /* comp_unit_die is not stored in die_hash, no need. */
20538 /* We try not to read any attributes in this function, because not
20539 all CUs needed for references have been loaded yet, and symbol
20540 table processing isn't initialized. But we have to set the CU language,
20541 or we won't be able to build types correctly.
20542 Similarly, if we do not read the producer, we can not apply
20543 producer-specific interpretation. */
20544 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
20547 /* Read in a signatured type and build its CU and DIEs.
20548 If the type is a stub for the real type in a DWO file,
20549 read in the real type from the DWO file as well. */
20552 read_signatured_type (struct signatured_type
*sig_type
)
20554 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
20556 gdb_assert (per_cu
->is_debug_types
);
20557 gdb_assert (per_cu
->cu
== NULL
);
20559 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
20560 read_signatured_type_reader
, NULL
);
20561 sig_type
->per_cu
.tu_read
= 1;
20564 /* Decode simple location descriptions.
20565 Given a pointer to a dwarf block that defines a location, compute
20566 the location and return the value.
20568 NOTE drow/2003-11-18: This function is called in two situations
20569 now: for the address of static or global variables (partial symbols
20570 only) and for offsets into structures which are expected to be
20571 (more or less) constant. The partial symbol case should go away,
20572 and only the constant case should remain. That will let this
20573 function complain more accurately. A few special modes are allowed
20574 without complaint for global variables (for instance, global
20575 register values and thread-local values).
20577 A location description containing no operations indicates that the
20578 object is optimized out. The return value is 0 for that case.
20579 FIXME drow/2003-11-16: No callers check for this case any more; soon all
20580 callers will only want a very basic result and this can become a
20583 Note that stack[0] is unused except as a default error return. */
20586 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
20588 struct objfile
*objfile
= cu
->objfile
;
20590 size_t size
= blk
->size
;
20591 const gdb_byte
*data
= blk
->data
;
20592 CORE_ADDR stack
[64];
20594 unsigned int bytes_read
, unsnd
;
20600 stack
[++stacki
] = 0;
20639 stack
[++stacki
] = op
- DW_OP_lit0
;
20674 stack
[++stacki
] = op
- DW_OP_reg0
;
20676 dwarf2_complex_location_expr_complaint ();
20680 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
20682 stack
[++stacki
] = unsnd
;
20684 dwarf2_complex_location_expr_complaint ();
20688 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
20693 case DW_OP_const1u
:
20694 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
20698 case DW_OP_const1s
:
20699 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
20703 case DW_OP_const2u
:
20704 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
20708 case DW_OP_const2s
:
20709 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
20713 case DW_OP_const4u
:
20714 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
20718 case DW_OP_const4s
:
20719 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
20723 case DW_OP_const8u
:
20724 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
20729 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
20735 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
20740 stack
[stacki
+ 1] = stack
[stacki
];
20745 stack
[stacki
- 1] += stack
[stacki
];
20749 case DW_OP_plus_uconst
:
20750 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
20756 stack
[stacki
- 1] -= stack
[stacki
];
20761 /* If we're not the last op, then we definitely can't encode
20762 this using GDB's address_class enum. This is valid for partial
20763 global symbols, although the variable's address will be bogus
20766 dwarf2_complex_location_expr_complaint ();
20769 case DW_OP_GNU_push_tls_address
:
20770 case DW_OP_form_tls_address
:
20771 /* The top of the stack has the offset from the beginning
20772 of the thread control block at which the variable is located. */
20773 /* Nothing should follow this operator, so the top of stack would
20775 /* This is valid for partial global symbols, but the variable's
20776 address will be bogus in the psymtab. Make it always at least
20777 non-zero to not look as a variable garbage collected by linker
20778 which have DW_OP_addr 0. */
20780 dwarf2_complex_location_expr_complaint ();
20784 case DW_OP_GNU_uninit
:
20787 case DW_OP_GNU_addr_index
:
20788 case DW_OP_GNU_const_index
:
20789 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
20796 const char *name
= get_DW_OP_name (op
);
20799 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
20802 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
20806 return (stack
[stacki
]);
20809 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20810 outside of the allocated space. Also enforce minimum>0. */
20811 if (stacki
>= ARRAY_SIZE (stack
) - 1)
20813 complaint (&symfile_complaints
,
20814 _("location description stack overflow"));
20820 complaint (&symfile_complaints
,
20821 _("location description stack underflow"));
20825 return (stack
[stacki
]);
20828 /* memory allocation interface */
20830 static struct dwarf_block
*
20831 dwarf_alloc_block (struct dwarf2_cu
*cu
)
20833 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
20836 static struct die_info
*
20837 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
20839 struct die_info
*die
;
20840 size_t size
= sizeof (struct die_info
);
20843 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
20845 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
20846 memset (die
, 0, sizeof (struct die_info
));
20851 /* Macro support. */
20853 /* Return file name relative to the compilation directory of file number I in
20854 *LH's file name table. The result is allocated using xmalloc; the caller is
20855 responsible for freeing it. */
20858 file_file_name (int file
, struct line_header
*lh
)
20860 /* Is the file number a valid index into the line header's file name
20861 table? Remember that file numbers start with one, not zero. */
20862 if (1 <= file
&& file
<= lh
->num_file_names
)
20864 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
20866 if (IS_ABSOLUTE_PATH (fe
->name
) || fe
->dir_index
== 0
20867 || lh
->include_dirs
== NULL
)
20868 return xstrdup (fe
->name
);
20869 return concat (lh
->include_dirs
[fe
->dir_index
- 1], SLASH_STRING
,
20870 fe
->name
, (char *) NULL
);
20874 /* The compiler produced a bogus file number. We can at least
20875 record the macro definitions made in the file, even if we
20876 won't be able to find the file by name. */
20877 char fake_name
[80];
20879 xsnprintf (fake_name
, sizeof (fake_name
),
20880 "<bad macro file number %d>", file
);
20882 complaint (&symfile_complaints
,
20883 _("bad file number in macro information (%d)"),
20886 return xstrdup (fake_name
);
20890 /* Return the full name of file number I in *LH's file name table.
20891 Use COMP_DIR as the name of the current directory of the
20892 compilation. The result is allocated using xmalloc; the caller is
20893 responsible for freeing it. */
20895 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
20897 /* Is the file number a valid index into the line header's file name
20898 table? Remember that file numbers start with one, not zero. */
20899 if (1 <= file
&& file
<= lh
->num_file_names
)
20901 char *relative
= file_file_name (file
, lh
);
20903 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
20905 return reconcat (relative
, comp_dir
, SLASH_STRING
,
20906 relative
, (char *) NULL
);
20909 return file_file_name (file
, lh
);
20913 static struct macro_source_file
*
20914 macro_start_file (int file
, int line
,
20915 struct macro_source_file
*current_file
,
20916 struct line_header
*lh
)
20918 /* File name relative to the compilation directory of this source file. */
20919 char *file_name
= file_file_name (file
, lh
);
20921 if (! current_file
)
20923 /* Note: We don't create a macro table for this compilation unit
20924 at all until we actually get a filename. */
20925 struct macro_table
*macro_table
= get_macro_table ();
20927 /* If we have no current file, then this must be the start_file
20928 directive for the compilation unit's main source file. */
20929 current_file
= macro_set_main (macro_table
, file_name
);
20930 macro_define_special (macro_table
);
20933 current_file
= macro_include (current_file
, line
, file_name
);
20937 return current_file
;
20941 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20942 followed by a null byte. */
20944 copy_string (const char *buf
, int len
)
20946 char *s
= (char *) xmalloc (len
+ 1);
20948 memcpy (s
, buf
, len
);
20954 static const char *
20955 consume_improper_spaces (const char *p
, const char *body
)
20959 complaint (&symfile_complaints
,
20960 _("macro definition contains spaces "
20961 "in formal argument list:\n`%s'"),
20973 parse_macro_definition (struct macro_source_file
*file
, int line
,
20978 /* The body string takes one of two forms. For object-like macro
20979 definitions, it should be:
20981 <macro name> " " <definition>
20983 For function-like macro definitions, it should be:
20985 <macro name> "() " <definition>
20987 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20989 Spaces may appear only where explicitly indicated, and in the
20992 The Dwarf 2 spec says that an object-like macro's name is always
20993 followed by a space, but versions of GCC around March 2002 omit
20994 the space when the macro's definition is the empty string.
20996 The Dwarf 2 spec says that there should be no spaces between the
20997 formal arguments in a function-like macro's formal argument list,
20998 but versions of GCC around March 2002 include spaces after the
21002 /* Find the extent of the macro name. The macro name is terminated
21003 by either a space or null character (for an object-like macro) or
21004 an opening paren (for a function-like macro). */
21005 for (p
= body
; *p
; p
++)
21006 if (*p
== ' ' || *p
== '(')
21009 if (*p
== ' ' || *p
== '\0')
21011 /* It's an object-like macro. */
21012 int name_len
= p
- body
;
21013 char *name
= copy_string (body
, name_len
);
21014 const char *replacement
;
21017 replacement
= body
+ name_len
+ 1;
21020 dwarf2_macro_malformed_definition_complaint (body
);
21021 replacement
= body
+ name_len
;
21024 macro_define_object (file
, line
, name
, replacement
);
21028 else if (*p
== '(')
21030 /* It's a function-like macro. */
21031 char *name
= copy_string (body
, p
- body
);
21034 char **argv
= XNEWVEC (char *, argv_size
);
21038 p
= consume_improper_spaces (p
, body
);
21040 /* Parse the formal argument list. */
21041 while (*p
&& *p
!= ')')
21043 /* Find the extent of the current argument name. */
21044 const char *arg_start
= p
;
21046 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
21049 if (! *p
|| p
== arg_start
)
21050 dwarf2_macro_malformed_definition_complaint (body
);
21053 /* Make sure argv has room for the new argument. */
21054 if (argc
>= argv_size
)
21057 argv
= XRESIZEVEC (char *, argv
, argv_size
);
21060 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
21063 p
= consume_improper_spaces (p
, body
);
21065 /* Consume the comma, if present. */
21070 p
= consume_improper_spaces (p
, body
);
21079 /* Perfectly formed definition, no complaints. */
21080 macro_define_function (file
, line
, name
,
21081 argc
, (const char **) argv
,
21083 else if (*p
== '\0')
21085 /* Complain, but do define it. */
21086 dwarf2_macro_malformed_definition_complaint (body
);
21087 macro_define_function (file
, line
, name
,
21088 argc
, (const char **) argv
,
21092 /* Just complain. */
21093 dwarf2_macro_malformed_definition_complaint (body
);
21096 /* Just complain. */
21097 dwarf2_macro_malformed_definition_complaint (body
);
21103 for (i
= 0; i
< argc
; i
++)
21109 dwarf2_macro_malformed_definition_complaint (body
);
21112 /* Skip some bytes from BYTES according to the form given in FORM.
21113 Returns the new pointer. */
21115 static const gdb_byte
*
21116 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
21117 enum dwarf_form form
,
21118 unsigned int offset_size
,
21119 struct dwarf2_section_info
*section
)
21121 unsigned int bytes_read
;
21125 case DW_FORM_data1
:
21130 case DW_FORM_data2
:
21134 case DW_FORM_data4
:
21138 case DW_FORM_data8
:
21142 case DW_FORM_string
:
21143 read_direct_string (abfd
, bytes
, &bytes_read
);
21144 bytes
+= bytes_read
;
21147 case DW_FORM_sec_offset
:
21149 case DW_FORM_GNU_strp_alt
:
21150 bytes
+= offset_size
;
21153 case DW_FORM_block
:
21154 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
21155 bytes
+= bytes_read
;
21158 case DW_FORM_block1
:
21159 bytes
+= 1 + read_1_byte (abfd
, bytes
);
21161 case DW_FORM_block2
:
21162 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
21164 case DW_FORM_block4
:
21165 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
21168 case DW_FORM_sdata
:
21169 case DW_FORM_udata
:
21170 case DW_FORM_GNU_addr_index
:
21171 case DW_FORM_GNU_str_index
:
21172 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
21175 dwarf2_section_buffer_overflow_complaint (section
);
21183 complaint (&symfile_complaints
,
21184 _("invalid form 0x%x in `%s'"),
21185 form
, get_section_name (section
));
21193 /* A helper for dwarf_decode_macros that handles skipping an unknown
21194 opcode. Returns an updated pointer to the macro data buffer; or,
21195 on error, issues a complaint and returns NULL. */
21197 static const gdb_byte
*
21198 skip_unknown_opcode (unsigned int opcode
,
21199 const gdb_byte
**opcode_definitions
,
21200 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21202 unsigned int offset_size
,
21203 struct dwarf2_section_info
*section
)
21205 unsigned int bytes_read
, i
;
21207 const gdb_byte
*defn
;
21209 if (opcode_definitions
[opcode
] == NULL
)
21211 complaint (&symfile_complaints
,
21212 _("unrecognized DW_MACFINO opcode 0x%x"),
21217 defn
= opcode_definitions
[opcode
];
21218 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
21219 defn
+= bytes_read
;
21221 for (i
= 0; i
< arg
; ++i
)
21223 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
21224 (enum dwarf_form
) defn
[i
], offset_size
,
21226 if (mac_ptr
== NULL
)
21228 /* skip_form_bytes already issued the complaint. */
21236 /* A helper function which parses the header of a macro section.
21237 If the macro section is the extended (for now called "GNU") type,
21238 then this updates *OFFSET_SIZE. Returns a pointer to just after
21239 the header, or issues a complaint and returns NULL on error. */
21241 static const gdb_byte
*
21242 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
21244 const gdb_byte
*mac_ptr
,
21245 unsigned int *offset_size
,
21246 int section_is_gnu
)
21248 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
21250 if (section_is_gnu
)
21252 unsigned int version
, flags
;
21254 version
= read_2_bytes (abfd
, mac_ptr
);
21257 complaint (&symfile_complaints
,
21258 _("unrecognized version `%d' in .debug_macro section"),
21264 flags
= read_1_byte (abfd
, mac_ptr
);
21266 *offset_size
= (flags
& 1) ? 8 : 4;
21268 if ((flags
& 2) != 0)
21269 /* We don't need the line table offset. */
21270 mac_ptr
+= *offset_size
;
21272 /* Vendor opcode descriptions. */
21273 if ((flags
& 4) != 0)
21275 unsigned int i
, count
;
21277 count
= read_1_byte (abfd
, mac_ptr
);
21279 for (i
= 0; i
< count
; ++i
)
21281 unsigned int opcode
, bytes_read
;
21284 opcode
= read_1_byte (abfd
, mac_ptr
);
21286 opcode_definitions
[opcode
] = mac_ptr
;
21287 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21288 mac_ptr
+= bytes_read
;
21297 /* A helper for dwarf_decode_macros that handles the GNU extensions,
21298 including DW_MACRO_GNU_transparent_include. */
21301 dwarf_decode_macro_bytes (bfd
*abfd
,
21302 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21303 struct macro_source_file
*current_file
,
21304 struct line_header
*lh
,
21305 struct dwarf2_section_info
*section
,
21306 int section_is_gnu
, int section_is_dwz
,
21307 unsigned int offset_size
,
21308 htab_t include_hash
)
21310 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21311 enum dwarf_macro_record_type macinfo_type
;
21312 int at_commandline
;
21313 const gdb_byte
*opcode_definitions
[256];
21315 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21316 &offset_size
, section_is_gnu
);
21317 if (mac_ptr
== NULL
)
21319 /* We already issued a complaint. */
21323 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
21324 GDB is still reading the definitions from command line. First
21325 DW_MACINFO_start_file will need to be ignored as it was already executed
21326 to create CURRENT_FILE for the main source holding also the command line
21327 definitions. On first met DW_MACINFO_start_file this flag is reset to
21328 normally execute all the remaining DW_MACINFO_start_file macinfos. */
21330 at_commandline
= 1;
21334 /* Do we at least have room for a macinfo type byte? */
21335 if (mac_ptr
>= mac_end
)
21337 dwarf2_section_buffer_overflow_complaint (section
);
21341 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
21344 /* Note that we rely on the fact that the corresponding GNU and
21345 DWARF constants are the same. */
21346 switch (macinfo_type
)
21348 /* A zero macinfo type indicates the end of the macro
21353 case DW_MACRO_GNU_define
:
21354 case DW_MACRO_GNU_undef
:
21355 case DW_MACRO_GNU_define_indirect
:
21356 case DW_MACRO_GNU_undef_indirect
:
21357 case DW_MACRO_GNU_define_indirect_alt
:
21358 case DW_MACRO_GNU_undef_indirect_alt
:
21360 unsigned int bytes_read
;
21365 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21366 mac_ptr
+= bytes_read
;
21368 if (macinfo_type
== DW_MACRO_GNU_define
21369 || macinfo_type
== DW_MACRO_GNU_undef
)
21371 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21372 mac_ptr
+= bytes_read
;
21376 LONGEST str_offset
;
21378 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21379 mac_ptr
+= offset_size
;
21381 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
21382 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
21385 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21387 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
21390 body
= read_indirect_string_at_offset (abfd
, str_offset
);
21393 is_define
= (macinfo_type
== DW_MACRO_GNU_define
21394 || macinfo_type
== DW_MACRO_GNU_define_indirect
21395 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
21396 if (! current_file
)
21398 /* DWARF violation as no main source is present. */
21399 complaint (&symfile_complaints
,
21400 _("debug info with no main source gives macro %s "
21402 is_define
? _("definition") : _("undefinition"),
21406 if ((line
== 0 && !at_commandline
)
21407 || (line
!= 0 && at_commandline
))
21408 complaint (&symfile_complaints
,
21409 _("debug info gives %s macro %s with %s line %d: %s"),
21410 at_commandline
? _("command-line") : _("in-file"),
21411 is_define
? _("definition") : _("undefinition"),
21412 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
21415 parse_macro_definition (current_file
, line
, body
);
21418 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
21419 || macinfo_type
== DW_MACRO_GNU_undef_indirect
21420 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
21421 macro_undef (current_file
, line
, body
);
21426 case DW_MACRO_GNU_start_file
:
21428 unsigned int bytes_read
;
21431 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21432 mac_ptr
+= bytes_read
;
21433 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21434 mac_ptr
+= bytes_read
;
21436 if ((line
== 0 && !at_commandline
)
21437 || (line
!= 0 && at_commandline
))
21438 complaint (&symfile_complaints
,
21439 _("debug info gives source %d included "
21440 "from %s at %s line %d"),
21441 file
, at_commandline
? _("command-line") : _("file"),
21442 line
== 0 ? _("zero") : _("non-zero"), line
);
21444 if (at_commandline
)
21446 /* This DW_MACRO_GNU_start_file was executed in the
21448 at_commandline
= 0;
21451 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21455 case DW_MACRO_GNU_end_file
:
21456 if (! current_file
)
21457 complaint (&symfile_complaints
,
21458 _("macro debug info has an unmatched "
21459 "`close_file' directive"));
21462 current_file
= current_file
->included_by
;
21463 if (! current_file
)
21465 enum dwarf_macro_record_type next_type
;
21467 /* GCC circa March 2002 doesn't produce the zero
21468 type byte marking the end of the compilation
21469 unit. Complain if it's not there, but exit no
21472 /* Do we at least have room for a macinfo type byte? */
21473 if (mac_ptr
>= mac_end
)
21475 dwarf2_section_buffer_overflow_complaint (section
);
21479 /* We don't increment mac_ptr here, so this is just
21482 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
21484 if (next_type
!= 0)
21485 complaint (&symfile_complaints
,
21486 _("no terminating 0-type entry for "
21487 "macros in `.debug_macinfo' section"));
21494 case DW_MACRO_GNU_transparent_include
:
21495 case DW_MACRO_GNU_transparent_include_alt
:
21499 bfd
*include_bfd
= abfd
;
21500 struct dwarf2_section_info
*include_section
= section
;
21501 const gdb_byte
*include_mac_end
= mac_end
;
21502 int is_dwz
= section_is_dwz
;
21503 const gdb_byte
*new_mac_ptr
;
21505 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21506 mac_ptr
+= offset_size
;
21508 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
21510 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21512 dwarf2_read_section (objfile
, &dwz
->macro
);
21514 include_section
= &dwz
->macro
;
21515 include_bfd
= get_section_bfd_owner (include_section
);
21516 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
21520 new_mac_ptr
= include_section
->buffer
+ offset
;
21521 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
21525 /* This has actually happened; see
21526 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
21527 complaint (&symfile_complaints
,
21528 _("recursive DW_MACRO_GNU_transparent_include in "
21529 ".debug_macro section"));
21533 *slot
= (void *) new_mac_ptr
;
21535 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
21536 include_mac_end
, current_file
, lh
,
21537 section
, section_is_gnu
, is_dwz
,
21538 offset_size
, include_hash
);
21540 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
21545 case DW_MACINFO_vendor_ext
:
21546 if (!section_is_gnu
)
21548 unsigned int bytes_read
;
21550 /* This reads the constant, but since we don't recognize
21551 any vendor extensions, we ignore it. */
21552 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21553 mac_ptr
+= bytes_read
;
21554 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21555 mac_ptr
+= bytes_read
;
21557 /* We don't recognize any vendor extensions. */
21563 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21564 mac_ptr
, mac_end
, abfd
, offset_size
,
21566 if (mac_ptr
== NULL
)
21570 } while (macinfo_type
!= 0);
21574 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
21575 int section_is_gnu
)
21577 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21578 struct line_header
*lh
= cu
->line_header
;
21580 const gdb_byte
*mac_ptr
, *mac_end
;
21581 struct macro_source_file
*current_file
= 0;
21582 enum dwarf_macro_record_type macinfo_type
;
21583 unsigned int offset_size
= cu
->header
.offset_size
;
21584 const gdb_byte
*opcode_definitions
[256];
21585 struct cleanup
*cleanup
;
21586 htab_t include_hash
;
21588 struct dwarf2_section_info
*section
;
21589 const char *section_name
;
21591 if (cu
->dwo_unit
!= NULL
)
21593 if (section_is_gnu
)
21595 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
21596 section_name
= ".debug_macro.dwo";
21600 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
21601 section_name
= ".debug_macinfo.dwo";
21606 if (section_is_gnu
)
21608 section
= &dwarf2_per_objfile
->macro
;
21609 section_name
= ".debug_macro";
21613 section
= &dwarf2_per_objfile
->macinfo
;
21614 section_name
= ".debug_macinfo";
21618 dwarf2_read_section (objfile
, section
);
21619 if (section
->buffer
== NULL
)
21621 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
21624 abfd
= get_section_bfd_owner (section
);
21626 /* First pass: Find the name of the base filename.
21627 This filename is needed in order to process all macros whose definition
21628 (or undefinition) comes from the command line. These macros are defined
21629 before the first DW_MACINFO_start_file entry, and yet still need to be
21630 associated to the base file.
21632 To determine the base file name, we scan the macro definitions until we
21633 reach the first DW_MACINFO_start_file entry. We then initialize
21634 CURRENT_FILE accordingly so that any macro definition found before the
21635 first DW_MACINFO_start_file can still be associated to the base file. */
21637 mac_ptr
= section
->buffer
+ offset
;
21638 mac_end
= section
->buffer
+ section
->size
;
21640 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21641 &offset_size
, section_is_gnu
);
21642 if (mac_ptr
== NULL
)
21644 /* We already issued a complaint. */
21650 /* Do we at least have room for a macinfo type byte? */
21651 if (mac_ptr
>= mac_end
)
21653 /* Complaint is printed during the second pass as GDB will probably
21654 stop the first pass earlier upon finding
21655 DW_MACINFO_start_file. */
21659 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
21662 /* Note that we rely on the fact that the corresponding GNU and
21663 DWARF constants are the same. */
21664 switch (macinfo_type
)
21666 /* A zero macinfo type indicates the end of the macro
21671 case DW_MACRO_GNU_define
:
21672 case DW_MACRO_GNU_undef
:
21673 /* Only skip the data by MAC_PTR. */
21675 unsigned int bytes_read
;
21677 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21678 mac_ptr
+= bytes_read
;
21679 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21680 mac_ptr
+= bytes_read
;
21684 case DW_MACRO_GNU_start_file
:
21686 unsigned int bytes_read
;
21689 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21690 mac_ptr
+= bytes_read
;
21691 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21692 mac_ptr
+= bytes_read
;
21694 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21698 case DW_MACRO_GNU_end_file
:
21699 /* No data to skip by MAC_PTR. */
21702 case DW_MACRO_GNU_define_indirect
:
21703 case DW_MACRO_GNU_undef_indirect
:
21704 case DW_MACRO_GNU_define_indirect_alt
:
21705 case DW_MACRO_GNU_undef_indirect_alt
:
21707 unsigned int bytes_read
;
21709 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21710 mac_ptr
+= bytes_read
;
21711 mac_ptr
+= offset_size
;
21715 case DW_MACRO_GNU_transparent_include
:
21716 case DW_MACRO_GNU_transparent_include_alt
:
21717 /* Note that, according to the spec, a transparent include
21718 chain cannot call DW_MACRO_GNU_start_file. So, we can just
21719 skip this opcode. */
21720 mac_ptr
+= offset_size
;
21723 case DW_MACINFO_vendor_ext
:
21724 /* Only skip the data by MAC_PTR. */
21725 if (!section_is_gnu
)
21727 unsigned int bytes_read
;
21729 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21730 mac_ptr
+= bytes_read
;
21731 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21732 mac_ptr
+= bytes_read
;
21737 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21738 mac_ptr
, mac_end
, abfd
, offset_size
,
21740 if (mac_ptr
== NULL
)
21744 } while (macinfo_type
!= 0 && current_file
== NULL
);
21746 /* Second pass: Process all entries.
21748 Use the AT_COMMAND_LINE flag to determine whether we are still processing
21749 command-line macro definitions/undefinitions. This flag is unset when we
21750 reach the first DW_MACINFO_start_file entry. */
21752 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
21753 NULL
, xcalloc
, xfree
);
21754 cleanup
= make_cleanup_htab_delete (include_hash
);
21755 mac_ptr
= section
->buffer
+ offset
;
21756 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
21757 *slot
= (void *) mac_ptr
;
21758 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
21759 current_file
, lh
, section
,
21760 section_is_gnu
, 0, offset_size
, include_hash
);
21761 do_cleanups (cleanup
);
21764 /* Check if the attribute's form is a DW_FORM_block*
21765 if so return true else false. */
21768 attr_form_is_block (const struct attribute
*attr
)
21770 return (attr
== NULL
? 0 :
21771 attr
->form
== DW_FORM_block1
21772 || attr
->form
== DW_FORM_block2
21773 || attr
->form
== DW_FORM_block4
21774 || attr
->form
== DW_FORM_block
21775 || attr
->form
== DW_FORM_exprloc
);
21778 /* Return non-zero if ATTR's value is a section offset --- classes
21779 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21780 You may use DW_UNSND (attr) to retrieve such offsets.
21782 Section 7.5.4, "Attribute Encodings", explains that no attribute
21783 may have a value that belongs to more than one of these classes; it
21784 would be ambiguous if we did, because we use the same forms for all
21788 attr_form_is_section_offset (const struct attribute
*attr
)
21790 return (attr
->form
== DW_FORM_data4
21791 || attr
->form
== DW_FORM_data8
21792 || attr
->form
== DW_FORM_sec_offset
);
21795 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21796 zero otherwise. When this function returns true, you can apply
21797 dwarf2_get_attr_constant_value to it.
21799 However, note that for some attributes you must check
21800 attr_form_is_section_offset before using this test. DW_FORM_data4
21801 and DW_FORM_data8 are members of both the constant class, and of
21802 the classes that contain offsets into other debug sections
21803 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21804 that, if an attribute's can be either a constant or one of the
21805 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21806 taken as section offsets, not constants. */
21809 attr_form_is_constant (const struct attribute
*attr
)
21811 switch (attr
->form
)
21813 case DW_FORM_sdata
:
21814 case DW_FORM_udata
:
21815 case DW_FORM_data1
:
21816 case DW_FORM_data2
:
21817 case DW_FORM_data4
:
21818 case DW_FORM_data8
:
21826 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21827 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21830 attr_form_is_ref (const struct attribute
*attr
)
21832 switch (attr
->form
)
21834 case DW_FORM_ref_addr
:
21839 case DW_FORM_ref_udata
:
21840 case DW_FORM_GNU_ref_alt
:
21847 /* Return the .debug_loc section to use for CU.
21848 For DWO files use .debug_loc.dwo. */
21850 static struct dwarf2_section_info
*
21851 cu_debug_loc_section (struct dwarf2_cu
*cu
)
21854 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
21855 return &dwarf2_per_objfile
->loc
;
21858 /* A helper function that fills in a dwarf2_loclist_baton. */
21861 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
21862 struct dwarf2_loclist_baton
*baton
,
21863 const struct attribute
*attr
)
21865 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21867 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
21869 baton
->per_cu
= cu
->per_cu
;
21870 gdb_assert (baton
->per_cu
);
21871 /* We don't know how long the location list is, but make sure we
21872 don't run off the edge of the section. */
21873 baton
->size
= section
->size
- DW_UNSND (attr
);
21874 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
21875 baton
->base_address
= cu
->base_address
;
21876 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
21880 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
21881 struct dwarf2_cu
*cu
, int is_block
)
21883 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21884 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21886 if (attr_form_is_section_offset (attr
)
21887 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21888 the section. If so, fall through to the complaint in the
21890 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
21892 struct dwarf2_loclist_baton
*baton
;
21894 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
21896 fill_in_loclist_baton (cu
, baton
, attr
);
21898 if (cu
->base_known
== 0)
21899 complaint (&symfile_complaints
,
21900 _("Location list used without "
21901 "specifying the CU base address."));
21903 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21904 ? dwarf2_loclist_block_index
21905 : dwarf2_loclist_index
);
21906 SYMBOL_LOCATION_BATON (sym
) = baton
;
21910 struct dwarf2_locexpr_baton
*baton
;
21912 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
21913 baton
->per_cu
= cu
->per_cu
;
21914 gdb_assert (baton
->per_cu
);
21916 if (attr_form_is_block (attr
))
21918 /* Note that we're just copying the block's data pointer
21919 here, not the actual data. We're still pointing into the
21920 info_buffer for SYM's objfile; right now we never release
21921 that buffer, but when we do clean up properly this may
21923 baton
->size
= DW_BLOCK (attr
)->size
;
21924 baton
->data
= DW_BLOCK (attr
)->data
;
21928 dwarf2_invalid_attrib_class_complaint ("location description",
21929 SYMBOL_NATURAL_NAME (sym
));
21933 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21934 ? dwarf2_locexpr_block_index
21935 : dwarf2_locexpr_index
);
21936 SYMBOL_LOCATION_BATON (sym
) = baton
;
21940 /* Return the OBJFILE associated with the compilation unit CU. If CU
21941 came from a separate debuginfo file, then the master objfile is
21945 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
21947 struct objfile
*objfile
= per_cu
->objfile
;
21949 /* Return the master objfile, so that we can report and look up the
21950 correct file containing this variable. */
21951 if (objfile
->separate_debug_objfile_backlink
)
21952 objfile
= objfile
->separate_debug_objfile_backlink
;
21957 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21958 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21959 CU_HEADERP first. */
21961 static const struct comp_unit_head
*
21962 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
21963 struct dwarf2_per_cu_data
*per_cu
)
21965 const gdb_byte
*info_ptr
;
21968 return &per_cu
->cu
->header
;
21970 info_ptr
= per_cu
->section
->buffer
+ per_cu
->offset
.sect_off
;
21972 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
21973 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
21978 /* Return the address size given in the compilation unit header for CU. */
21981 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21983 struct comp_unit_head cu_header_local
;
21984 const struct comp_unit_head
*cu_headerp
;
21986 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21988 return cu_headerp
->addr_size
;
21991 /* Return the offset size given in the compilation unit header for CU. */
21994 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
21996 struct comp_unit_head cu_header_local
;
21997 const struct comp_unit_head
*cu_headerp
;
21999 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
22001 return cu_headerp
->offset_size
;
22004 /* See its dwarf2loc.h declaration. */
22007 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
22009 struct comp_unit_head cu_header_local
;
22010 const struct comp_unit_head
*cu_headerp
;
22012 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
22014 if (cu_headerp
->version
== 2)
22015 return cu_headerp
->addr_size
;
22017 return cu_headerp
->offset_size
;
22020 /* Return the text offset of the CU. The returned offset comes from
22021 this CU's objfile. If this objfile came from a separate debuginfo
22022 file, then the offset may be different from the corresponding
22023 offset in the parent objfile. */
22026 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
22028 struct objfile
*objfile
= per_cu
->objfile
;
22030 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
22033 /* Locate the .debug_info compilation unit from CU's objfile which contains
22034 the DIE at OFFSET. Raises an error on failure. */
22036 static struct dwarf2_per_cu_data
*
22037 dwarf2_find_containing_comp_unit (sect_offset offset
,
22038 unsigned int offset_in_dwz
,
22039 struct objfile
*objfile
)
22041 struct dwarf2_per_cu_data
*this_cu
;
22043 const sect_offset
*cu_off
;
22046 high
= dwarf2_per_objfile
->n_comp_units
- 1;
22049 struct dwarf2_per_cu_data
*mid_cu
;
22050 int mid
= low
+ (high
- low
) / 2;
22052 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
22053 cu_off
= &mid_cu
->offset
;
22054 if (mid_cu
->is_dwz
> offset_in_dwz
22055 || (mid_cu
->is_dwz
== offset_in_dwz
22056 && cu_off
->sect_off
>= offset
.sect_off
))
22061 gdb_assert (low
== high
);
22062 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
22063 cu_off
= &this_cu
->offset
;
22064 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
22066 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
22067 error (_("Dwarf Error: could not find partial DIE containing "
22068 "offset 0x%lx [in module %s]"),
22069 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
22071 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
22072 <= offset
.sect_off
);
22073 return dwarf2_per_objfile
->all_comp_units
[low
-1];
22077 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
22078 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
22079 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
22080 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
22081 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
22086 /* Initialize dwarf2_cu CU, owned by PER_CU. */
22089 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
22091 memset (cu
, 0, sizeof (*cu
));
22093 cu
->per_cu
= per_cu
;
22094 cu
->objfile
= per_cu
->objfile
;
22095 obstack_init (&cu
->comp_unit_obstack
);
22098 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
22101 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
22102 enum language pretend_language
)
22104 struct attribute
*attr
;
22106 /* Set the language we're debugging. */
22107 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
22109 set_cu_language (DW_UNSND (attr
), cu
);
22112 cu
->language
= pretend_language
;
22113 cu
->language_defn
= language_def (cu
->language
);
22116 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
22119 /* Release one cached compilation unit, CU. We unlink it from the tree
22120 of compilation units, but we don't remove it from the read_in_chain;
22121 the caller is responsible for that.
22122 NOTE: DATA is a void * because this function is also used as a
22123 cleanup routine. */
22126 free_heap_comp_unit (void *data
)
22128 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) data
;
22130 gdb_assert (cu
->per_cu
!= NULL
);
22131 cu
->per_cu
->cu
= NULL
;
22134 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22139 /* This cleanup function is passed the address of a dwarf2_cu on the stack
22140 when we're finished with it. We can't free the pointer itself, but be
22141 sure to unlink it from the cache. Also release any associated storage. */
22144 free_stack_comp_unit (void *data
)
22146 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) data
;
22148 gdb_assert (cu
->per_cu
!= NULL
);
22149 cu
->per_cu
->cu
= NULL
;
22152 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22153 cu
->partial_dies
= NULL
;
22156 /* Free all cached compilation units. */
22159 free_cached_comp_units (void *data
)
22161 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22163 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22164 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22165 while (per_cu
!= NULL
)
22167 struct dwarf2_per_cu_data
*next_cu
;
22169 next_cu
= per_cu
->cu
->read_in_chain
;
22171 free_heap_comp_unit (per_cu
->cu
);
22172 *last_chain
= next_cu
;
22178 /* Increase the age counter on each cached compilation unit, and free
22179 any that are too old. */
22182 age_cached_comp_units (void)
22184 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22186 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
22187 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22188 while (per_cu
!= NULL
)
22190 per_cu
->cu
->last_used
++;
22191 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
22192 dwarf2_mark (per_cu
->cu
);
22193 per_cu
= per_cu
->cu
->read_in_chain
;
22196 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22197 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22198 while (per_cu
!= NULL
)
22200 struct dwarf2_per_cu_data
*next_cu
;
22202 next_cu
= per_cu
->cu
->read_in_chain
;
22204 if (!per_cu
->cu
->mark
)
22206 free_heap_comp_unit (per_cu
->cu
);
22207 *last_chain
= next_cu
;
22210 last_chain
= &per_cu
->cu
->read_in_chain
;
22216 /* Remove a single compilation unit from the cache. */
22219 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
22221 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22223 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22224 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22225 while (per_cu
!= NULL
)
22227 struct dwarf2_per_cu_data
*next_cu
;
22229 next_cu
= per_cu
->cu
->read_in_chain
;
22231 if (per_cu
== target_per_cu
)
22233 free_heap_comp_unit (per_cu
->cu
);
22235 *last_chain
= next_cu
;
22239 last_chain
= &per_cu
->cu
->read_in_chain
;
22245 /* Release all extra memory associated with OBJFILE. */
22248 dwarf2_free_objfile (struct objfile
*objfile
)
22251 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
22252 dwarf2_objfile_data_key
);
22254 if (dwarf2_per_objfile
== NULL
)
22257 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
22258 free_cached_comp_units (NULL
);
22260 if (dwarf2_per_objfile
->quick_file_names_table
)
22261 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
22263 if (dwarf2_per_objfile
->line_header_hash
)
22264 htab_delete (dwarf2_per_objfile
->line_header_hash
);
22266 /* Everything else should be on the objfile obstack. */
22269 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
22270 We store these in a hash table separate from the DIEs, and preserve them
22271 when the DIEs are flushed out of cache.
22273 The CU "per_cu" pointer is needed because offset alone is not enough to
22274 uniquely identify the type. A file may have multiple .debug_types sections,
22275 or the type may come from a DWO file. Furthermore, while it's more logical
22276 to use per_cu->section+offset, with Fission the section with the data is in
22277 the DWO file but we don't know that section at the point we need it.
22278 We have to use something in dwarf2_per_cu_data (or the pointer to it)
22279 because we can enter the lookup routine, get_die_type_at_offset, from
22280 outside this file, and thus won't necessarily have PER_CU->cu.
22281 Fortunately, PER_CU is stable for the life of the objfile. */
22283 struct dwarf2_per_cu_offset_and_type
22285 const struct dwarf2_per_cu_data
*per_cu
;
22286 sect_offset offset
;
22290 /* Hash function for a dwarf2_per_cu_offset_and_type. */
22293 per_cu_offset_and_type_hash (const void *item
)
22295 const struct dwarf2_per_cu_offset_and_type
*ofs
22296 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
22298 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
22301 /* Equality function for a dwarf2_per_cu_offset_and_type. */
22304 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
22306 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
22307 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
22308 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
22309 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
22311 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
22312 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
22315 /* Set the type associated with DIE to TYPE. Save it in CU's hash
22316 table if necessary. For convenience, return TYPE.
22318 The DIEs reading must have careful ordering to:
22319 * Not cause infite loops trying to read in DIEs as a prerequisite for
22320 reading current DIE.
22321 * Not trying to dereference contents of still incompletely read in types
22322 while reading in other DIEs.
22323 * Enable referencing still incompletely read in types just by a pointer to
22324 the type without accessing its fields.
22326 Therefore caller should follow these rules:
22327 * Try to fetch any prerequisite types we may need to build this DIE type
22328 before building the type and calling set_die_type.
22329 * After building type call set_die_type for current DIE as soon as
22330 possible before fetching more types to complete the current type.
22331 * Make the type as complete as possible before fetching more types. */
22333 static struct type
*
22334 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
22336 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
22337 struct objfile
*objfile
= cu
->objfile
;
22338 struct attribute
*attr
;
22339 struct dynamic_prop prop
;
22341 /* For Ada types, make sure that the gnat-specific data is always
22342 initialized (if not already set). There are a few types where
22343 we should not be doing so, because the type-specific area is
22344 already used to hold some other piece of info (eg: TYPE_CODE_FLT
22345 where the type-specific area is used to store the floatformat).
22346 But this is not a problem, because the gnat-specific information
22347 is actually not needed for these types. */
22348 if (need_gnat_info (cu
)
22349 && TYPE_CODE (type
) != TYPE_CODE_FUNC
22350 && TYPE_CODE (type
) != TYPE_CODE_FLT
22351 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
22352 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
22353 && TYPE_CODE (type
) != TYPE_CODE_METHOD
22354 && !HAVE_GNAT_AUX_INFO (type
))
22355 INIT_GNAT_SPECIFIC (type
);
22357 /* Read DW_AT_allocated and set in type. */
22358 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
22359 if (attr_form_is_block (attr
))
22361 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
22362 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
, objfile
);
22364 else if (attr
!= NULL
)
22366 complaint (&symfile_complaints
,
22367 _("DW_AT_allocated has the wrong form (%s) at DIE 0x%x"),
22368 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
22369 die
->offset
.sect_off
);
22372 /* Read DW_AT_associated and set in type. */
22373 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
22374 if (attr_form_is_block (attr
))
22376 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
22377 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
, objfile
);
22379 else if (attr
!= NULL
)
22381 complaint (&symfile_complaints
,
22382 _("DW_AT_associated has the wrong form (%s) at DIE 0x%x"),
22383 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
22384 die
->offset
.sect_off
);
22387 /* Read DW_AT_data_location and set in type. */
22388 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
22389 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
22390 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
, objfile
);
22392 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22394 dwarf2_per_objfile
->die_type_hash
=
22395 htab_create_alloc_ex (127,
22396 per_cu_offset_and_type_hash
,
22397 per_cu_offset_and_type_eq
,
22399 &objfile
->objfile_obstack
,
22400 hashtab_obstack_allocate
,
22401 dummy_obstack_deallocate
);
22404 ofs
.per_cu
= cu
->per_cu
;
22405 ofs
.offset
= die
->offset
;
22407 slot
= (struct dwarf2_per_cu_offset_and_type
**)
22408 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
22410 complaint (&symfile_complaints
,
22411 _("A problem internal to GDB: DIE 0x%x has type already set"),
22412 die
->offset
.sect_off
);
22413 *slot
= XOBNEW (&objfile
->objfile_obstack
,
22414 struct dwarf2_per_cu_offset_and_type
);
22419 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
22420 or return NULL if the die does not have a saved type. */
22422 static struct type
*
22423 get_die_type_at_offset (sect_offset offset
,
22424 struct dwarf2_per_cu_data
*per_cu
)
22426 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
22428 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22431 ofs
.per_cu
= per_cu
;
22432 ofs
.offset
= offset
;
22433 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
22434 htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
));
22441 /* Look up the type for DIE in CU in die_type_hash,
22442 or return NULL if DIE does not have a saved type. */
22444 static struct type
*
22445 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22447 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
22450 /* Add a dependence relationship from CU to REF_PER_CU. */
22453 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
22454 struct dwarf2_per_cu_data
*ref_per_cu
)
22458 if (cu
->dependencies
== NULL
)
22460 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
22461 NULL
, &cu
->comp_unit_obstack
,
22462 hashtab_obstack_allocate
,
22463 dummy_obstack_deallocate
);
22465 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
22467 *slot
= ref_per_cu
;
22470 /* Subroutine of dwarf2_mark to pass to htab_traverse.
22471 Set the mark field in every compilation unit in the
22472 cache that we must keep because we are keeping CU. */
22475 dwarf2_mark_helper (void **slot
, void *data
)
22477 struct dwarf2_per_cu_data
*per_cu
;
22479 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
22481 /* cu->dependencies references may not yet have been ever read if QUIT aborts
22482 reading of the chain. As such dependencies remain valid it is not much
22483 useful to track and undo them during QUIT cleanups. */
22484 if (per_cu
->cu
== NULL
)
22487 if (per_cu
->cu
->mark
)
22489 per_cu
->cu
->mark
= 1;
22491 if (per_cu
->cu
->dependencies
!= NULL
)
22492 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22497 /* Set the mark field in CU and in every other compilation unit in the
22498 cache that we must keep because we are keeping CU. */
22501 dwarf2_mark (struct dwarf2_cu
*cu
)
22506 if (cu
->dependencies
!= NULL
)
22507 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22511 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
22515 per_cu
->cu
->mark
= 0;
22516 per_cu
= per_cu
->cu
->read_in_chain
;
22520 /* Trivial hash function for partial_die_info: the hash value of a DIE
22521 is its offset in .debug_info for this objfile. */
22524 partial_die_hash (const void *item
)
22526 const struct partial_die_info
*part_die
22527 = (const struct partial_die_info
*) item
;
22529 return part_die
->offset
.sect_off
;
22532 /* Trivial comparison function for partial_die_info structures: two DIEs
22533 are equal if they have the same offset. */
22536 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
22538 const struct partial_die_info
*part_die_lhs
22539 = (const struct partial_die_info
*) item_lhs
;
22540 const struct partial_die_info
*part_die_rhs
22541 = (const struct partial_die_info
*) item_rhs
;
22543 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
22546 static struct cmd_list_element
*set_dwarf_cmdlist
;
22547 static struct cmd_list_element
*show_dwarf_cmdlist
;
22550 set_dwarf_cmd (char *args
, int from_tty
)
22552 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
22557 show_dwarf_cmd (char *args
, int from_tty
)
22559 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
22562 /* Free data associated with OBJFILE, if necessary. */
22565 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
22567 struct dwarf2_per_objfile
*data
= (struct dwarf2_per_objfile
*) d
;
22570 /* Make sure we don't accidentally use dwarf2_per_objfile while
22572 dwarf2_per_objfile
= NULL
;
22574 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
22575 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
22577 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
22578 VEC_free (dwarf2_per_cu_ptr
,
22579 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
22580 xfree (data
->all_type_units
);
22582 VEC_free (dwarf2_section_info_def
, data
->types
);
22584 if (data
->dwo_files
)
22585 free_dwo_files (data
->dwo_files
, objfile
);
22586 if (data
->dwp_file
)
22587 gdb_bfd_unref (data
->dwp_file
->dbfd
);
22589 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
22590 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
22594 /* The "save gdb-index" command. */
22596 /* The contents of the hash table we create when building the string
22598 struct strtab_entry
22600 offset_type offset
;
22604 /* Hash function for a strtab_entry.
22606 Function is used only during write_hash_table so no index format backward
22607 compatibility is needed. */
22610 hash_strtab_entry (const void *e
)
22612 const struct strtab_entry
*entry
= (const struct strtab_entry
*) e
;
22613 return mapped_index_string_hash (INT_MAX
, entry
->str
);
22616 /* Equality function for a strtab_entry. */
22619 eq_strtab_entry (const void *a
, const void *b
)
22621 const struct strtab_entry
*ea
= (const struct strtab_entry
*) a
;
22622 const struct strtab_entry
*eb
= (const struct strtab_entry
*) b
;
22623 return !strcmp (ea
->str
, eb
->str
);
22626 /* Create a strtab_entry hash table. */
22629 create_strtab (void)
22631 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
22632 xfree
, xcalloc
, xfree
);
22635 /* Add a string to the constant pool. Return the string's offset in
22639 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
22642 struct strtab_entry entry
;
22643 struct strtab_entry
*result
;
22646 slot
= htab_find_slot (table
, &entry
, INSERT
);
22648 result
= (struct strtab_entry
*) *slot
;
22651 result
= XNEW (struct strtab_entry
);
22652 result
->offset
= obstack_object_size (cpool
);
22654 obstack_grow_str0 (cpool
, str
);
22657 return result
->offset
;
22660 /* An entry in the symbol table. */
22661 struct symtab_index_entry
22663 /* The name of the symbol. */
22665 /* The offset of the name in the constant pool. */
22666 offset_type index_offset
;
22667 /* A sorted vector of the indices of all the CUs that hold an object
22669 VEC (offset_type
) *cu_indices
;
22672 /* The symbol table. This is a power-of-2-sized hash table. */
22673 struct mapped_symtab
22675 offset_type n_elements
;
22677 struct symtab_index_entry
**data
;
22680 /* Hash function for a symtab_index_entry. */
22683 hash_symtab_entry (const void *e
)
22685 const struct symtab_index_entry
*entry
22686 = (const struct symtab_index_entry
*) e
;
22687 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
22688 sizeof (offset_type
) * VEC_length (offset_type
,
22689 entry
->cu_indices
),
22693 /* Equality function for a symtab_index_entry. */
22696 eq_symtab_entry (const void *a
, const void *b
)
22698 const struct symtab_index_entry
*ea
= (const struct symtab_index_entry
*) a
;
22699 const struct symtab_index_entry
*eb
= (const struct symtab_index_entry
*) b
;
22700 int len
= VEC_length (offset_type
, ea
->cu_indices
);
22701 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
22703 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
22704 VEC_address (offset_type
, eb
->cu_indices
),
22705 sizeof (offset_type
) * len
);
22708 /* Destroy a symtab_index_entry. */
22711 delete_symtab_entry (void *p
)
22713 struct symtab_index_entry
*entry
= (struct symtab_index_entry
*) p
;
22714 VEC_free (offset_type
, entry
->cu_indices
);
22718 /* Create a hash table holding symtab_index_entry objects. */
22721 create_symbol_hash_table (void)
22723 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
22724 delete_symtab_entry
, xcalloc
, xfree
);
22727 /* Create a new mapped symtab object. */
22729 static struct mapped_symtab
*
22730 create_mapped_symtab (void)
22732 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
22733 symtab
->n_elements
= 0;
22734 symtab
->size
= 1024;
22735 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22739 /* Destroy a mapped_symtab. */
22742 cleanup_mapped_symtab (void *p
)
22744 struct mapped_symtab
*symtab
= (struct mapped_symtab
*) p
;
22745 /* The contents of the array are freed when the other hash table is
22747 xfree (symtab
->data
);
22751 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22754 Function is used only during write_hash_table so no index format backward
22755 compatibility is needed. */
22757 static struct symtab_index_entry
**
22758 find_slot (struct mapped_symtab
*symtab
, const char *name
)
22760 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
22762 index
= hash
& (symtab
->size
- 1);
22763 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
22767 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
22768 return &symtab
->data
[index
];
22769 index
= (index
+ step
) & (symtab
->size
- 1);
22773 /* Expand SYMTAB's hash table. */
22776 hash_expand (struct mapped_symtab
*symtab
)
22778 offset_type old_size
= symtab
->size
;
22780 struct symtab_index_entry
**old_entries
= symtab
->data
;
22783 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22785 for (i
= 0; i
< old_size
; ++i
)
22787 if (old_entries
[i
])
22789 struct symtab_index_entry
**slot
= find_slot (symtab
,
22790 old_entries
[i
]->name
);
22791 *slot
= old_entries
[i
];
22795 xfree (old_entries
);
22798 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22799 CU_INDEX is the index of the CU in which the symbol appears.
22800 IS_STATIC is one if the symbol is static, otherwise zero (global). */
22803 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
22804 int is_static
, gdb_index_symbol_kind kind
,
22805 offset_type cu_index
)
22807 struct symtab_index_entry
**slot
;
22808 offset_type cu_index_and_attrs
;
22810 ++symtab
->n_elements
;
22811 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
22812 hash_expand (symtab
);
22814 slot
= find_slot (symtab
, name
);
22817 *slot
= XNEW (struct symtab_index_entry
);
22818 (*slot
)->name
= name
;
22819 /* index_offset is set later. */
22820 (*slot
)->cu_indices
= NULL
;
22823 cu_index_and_attrs
= 0;
22824 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
22825 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
22826 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
22828 /* We don't want to record an index value twice as we want to avoid the
22830 We process all global symbols and then all static symbols
22831 (which would allow us to avoid the duplication by only having to check
22832 the last entry pushed), but a symbol could have multiple kinds in one CU.
22833 To keep things simple we don't worry about the duplication here and
22834 sort and uniqufy the list after we've processed all symbols. */
22835 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
22838 /* qsort helper routine for uniquify_cu_indices. */
22841 offset_type_compare (const void *ap
, const void *bp
)
22843 offset_type a
= *(offset_type
*) ap
;
22844 offset_type b
= *(offset_type
*) bp
;
22846 return (a
> b
) - (b
> a
);
22849 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22852 uniquify_cu_indices (struct mapped_symtab
*symtab
)
22856 for (i
= 0; i
< symtab
->size
; ++i
)
22858 struct symtab_index_entry
*entry
= symtab
->data
[i
];
22861 && entry
->cu_indices
!= NULL
)
22863 unsigned int next_to_insert
, next_to_check
;
22864 offset_type last_value
;
22866 qsort (VEC_address (offset_type
, entry
->cu_indices
),
22867 VEC_length (offset_type
, entry
->cu_indices
),
22868 sizeof (offset_type
), offset_type_compare
);
22870 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
22871 next_to_insert
= 1;
22872 for (next_to_check
= 1;
22873 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
22876 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
22879 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
22881 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
22886 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
22891 /* Add a vector of indices to the constant pool. */
22894 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
22895 struct symtab_index_entry
*entry
)
22899 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
22902 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
22903 offset_type val
= MAYBE_SWAP (len
);
22908 entry
->index_offset
= obstack_object_size (cpool
);
22910 obstack_grow (cpool
, &val
, sizeof (val
));
22912 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
22915 val
= MAYBE_SWAP (iter
);
22916 obstack_grow (cpool
, &val
, sizeof (val
));
22921 struct symtab_index_entry
*old_entry
22922 = (struct symtab_index_entry
*) *slot
;
22923 entry
->index_offset
= old_entry
->index_offset
;
22926 return entry
->index_offset
;
22929 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22930 constant pool entries going into the obstack CPOOL. */
22933 write_hash_table (struct mapped_symtab
*symtab
,
22934 struct obstack
*output
, struct obstack
*cpool
)
22937 htab_t symbol_hash_table
;
22940 symbol_hash_table
= create_symbol_hash_table ();
22941 str_table
= create_strtab ();
22943 /* We add all the index vectors to the constant pool first, to
22944 ensure alignment is ok. */
22945 for (i
= 0; i
< symtab
->size
; ++i
)
22947 if (symtab
->data
[i
])
22948 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
22951 /* Now write out the hash table. */
22952 for (i
= 0; i
< symtab
->size
; ++i
)
22954 offset_type str_off
, vec_off
;
22956 if (symtab
->data
[i
])
22958 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
22959 vec_off
= symtab
->data
[i
]->index_offset
;
22963 /* While 0 is a valid constant pool index, it is not valid
22964 to have 0 for both offsets. */
22969 str_off
= MAYBE_SWAP (str_off
);
22970 vec_off
= MAYBE_SWAP (vec_off
);
22972 obstack_grow (output
, &str_off
, sizeof (str_off
));
22973 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
22976 htab_delete (str_table
);
22977 htab_delete (symbol_hash_table
);
22980 /* Struct to map psymtab to CU index in the index file. */
22981 struct psymtab_cu_index_map
22983 struct partial_symtab
*psymtab
;
22984 unsigned int cu_index
;
22988 hash_psymtab_cu_index (const void *item
)
22990 const struct psymtab_cu_index_map
*map
22991 = (const struct psymtab_cu_index_map
*) item
;
22993 return htab_hash_pointer (map
->psymtab
);
22997 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
22999 const struct psymtab_cu_index_map
*lhs
23000 = (const struct psymtab_cu_index_map
*) item_lhs
;
23001 const struct psymtab_cu_index_map
*rhs
23002 = (const struct psymtab_cu_index_map
*) item_rhs
;
23004 return lhs
->psymtab
== rhs
->psymtab
;
23007 /* Helper struct for building the address table. */
23008 struct addrmap_index_data
23010 struct objfile
*objfile
;
23011 struct obstack
*addr_obstack
;
23012 htab_t cu_index_htab
;
23014 /* Non-zero if the previous_* fields are valid.
23015 We can't write an entry until we see the next entry (since it is only then
23016 that we know the end of the entry). */
23017 int previous_valid
;
23018 /* Index of the CU in the table of all CUs in the index file. */
23019 unsigned int previous_cu_index
;
23020 /* Start address of the CU. */
23021 CORE_ADDR previous_cu_start
;
23024 /* Write an address entry to OBSTACK. */
23027 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
23028 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
23030 offset_type cu_index_to_write
;
23032 CORE_ADDR baseaddr
;
23034 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
23036 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
23037 obstack_grow (obstack
, addr
, 8);
23038 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
23039 obstack_grow (obstack
, addr
, 8);
23040 cu_index_to_write
= MAYBE_SWAP (cu_index
);
23041 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
23044 /* Worker function for traversing an addrmap to build the address table. */
23047 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
23049 struct addrmap_index_data
*data
= (struct addrmap_index_data
*) datap
;
23050 struct partial_symtab
*pst
= (struct partial_symtab
*) obj
;
23052 if (data
->previous_valid
)
23053 add_address_entry (data
->objfile
, data
->addr_obstack
,
23054 data
->previous_cu_start
, start_addr
,
23055 data
->previous_cu_index
);
23057 data
->previous_cu_start
= start_addr
;
23060 struct psymtab_cu_index_map find_map
, *map
;
23061 find_map
.psymtab
= pst
;
23062 map
= ((struct psymtab_cu_index_map
*)
23063 htab_find (data
->cu_index_htab
, &find_map
));
23064 gdb_assert (map
!= NULL
);
23065 data
->previous_cu_index
= map
->cu_index
;
23066 data
->previous_valid
= 1;
23069 data
->previous_valid
= 0;
23074 /* Write OBJFILE's address map to OBSTACK.
23075 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
23076 in the index file. */
23079 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
23080 htab_t cu_index_htab
)
23082 struct addrmap_index_data addrmap_index_data
;
23084 /* When writing the address table, we have to cope with the fact that
23085 the addrmap iterator only provides the start of a region; we have to
23086 wait until the next invocation to get the start of the next region. */
23088 addrmap_index_data
.objfile
= objfile
;
23089 addrmap_index_data
.addr_obstack
= obstack
;
23090 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
23091 addrmap_index_data
.previous_valid
= 0;
23093 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
23094 &addrmap_index_data
);
23096 /* It's highly unlikely the last entry (end address = 0xff...ff)
23097 is valid, but we should still handle it.
23098 The end address is recorded as the start of the next region, but that
23099 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
23101 if (addrmap_index_data
.previous_valid
)
23102 add_address_entry (objfile
, obstack
,
23103 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
23104 addrmap_index_data
.previous_cu_index
);
23107 /* Return the symbol kind of PSYM. */
23109 static gdb_index_symbol_kind
23110 symbol_kind (struct partial_symbol
*psym
)
23112 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
23113 enum address_class aclass
= PSYMBOL_CLASS (psym
);
23121 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
23123 return GDB_INDEX_SYMBOL_KIND_TYPE
;
23125 case LOC_CONST_BYTES
:
23126 case LOC_OPTIMIZED_OUT
:
23128 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
23130 /* Note: It's currently impossible to recognize psyms as enum values
23131 short of reading the type info. For now punt. */
23132 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
23134 /* There are other LOC_FOO values that one might want to classify
23135 as variables, but dwarf2read.c doesn't currently use them. */
23136 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23138 case STRUCT_DOMAIN
:
23139 return GDB_INDEX_SYMBOL_KIND_TYPE
;
23141 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23145 /* Add a list of partial symbols to SYMTAB. */
23148 write_psymbols (struct mapped_symtab
*symtab
,
23150 struct partial_symbol
**psymp
,
23152 offset_type cu_index
,
23155 for (; count
-- > 0; ++psymp
)
23157 struct partial_symbol
*psym
= *psymp
;
23160 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
23161 error (_("Ada is not currently supported by the index"));
23163 /* Only add a given psymbol once. */
23164 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
23167 gdb_index_symbol_kind kind
= symbol_kind (psym
);
23170 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
23171 is_static
, kind
, cu_index
);
23176 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
23177 exception if there is an error. */
23180 write_obstack (FILE *file
, struct obstack
*obstack
)
23182 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
23184 != obstack_object_size (obstack
))
23185 error (_("couldn't data write to file"));
23188 /* Unlink a file if the argument is not NULL. */
23191 unlink_if_set (void *p
)
23193 char **filename
= (char **) p
;
23195 unlink (*filename
);
23198 /* A helper struct used when iterating over debug_types. */
23199 struct signatured_type_index_data
23201 struct objfile
*objfile
;
23202 struct mapped_symtab
*symtab
;
23203 struct obstack
*types_list
;
23208 /* A helper function that writes a single signatured_type to an
23212 write_one_signatured_type (void **slot
, void *d
)
23214 struct signatured_type_index_data
*info
23215 = (struct signatured_type_index_data
*) d
;
23216 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
23217 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
23220 write_psymbols (info
->symtab
,
23222 info
->objfile
->global_psymbols
.list
23223 + psymtab
->globals_offset
,
23224 psymtab
->n_global_syms
, info
->cu_index
,
23226 write_psymbols (info
->symtab
,
23228 info
->objfile
->static_psymbols
.list
23229 + psymtab
->statics_offset
,
23230 psymtab
->n_static_syms
, info
->cu_index
,
23233 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23234 entry
->per_cu
.offset
.sect_off
);
23235 obstack_grow (info
->types_list
, val
, 8);
23236 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23237 entry
->type_offset_in_tu
.cu_off
);
23238 obstack_grow (info
->types_list
, val
, 8);
23239 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
23240 obstack_grow (info
->types_list
, val
, 8);
23247 /* Recurse into all "included" dependencies and write their symbols as
23248 if they appeared in this psymtab. */
23251 recursively_write_psymbols (struct objfile
*objfile
,
23252 struct partial_symtab
*psymtab
,
23253 struct mapped_symtab
*symtab
,
23255 offset_type cu_index
)
23259 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
23260 if (psymtab
->dependencies
[i
]->user
!= NULL
)
23261 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
23262 symtab
, psyms_seen
, cu_index
);
23264 write_psymbols (symtab
,
23266 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
23267 psymtab
->n_global_syms
, cu_index
,
23269 write_psymbols (symtab
,
23271 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
23272 psymtab
->n_static_syms
, cu_index
,
23276 /* Create an index file for OBJFILE in the directory DIR. */
23279 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
23281 struct cleanup
*cleanup
;
23282 char *filename
, *cleanup_filename
;
23283 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
23284 struct obstack cu_list
, types_cu_list
;
23287 struct mapped_symtab
*symtab
;
23288 offset_type val
, size_of_contents
, total_len
;
23291 htab_t cu_index_htab
;
23292 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
23294 if (dwarf2_per_objfile
->using_index
)
23295 error (_("Cannot use an index to create the index"));
23297 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
23298 error (_("Cannot make an index when the file has multiple .debug_types sections"));
23300 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
23303 if (stat (objfile_name (objfile
), &st
) < 0)
23304 perror_with_name (objfile_name (objfile
));
23306 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile_name (objfile
)),
23307 INDEX_SUFFIX
, (char *) NULL
);
23308 cleanup
= make_cleanup (xfree
, filename
);
23310 out_file
= gdb_fopen_cloexec (filename
, "wb");
23312 error (_("Can't open `%s' for writing"), filename
);
23314 cleanup_filename
= filename
;
23315 make_cleanup (unlink_if_set
, &cleanup_filename
);
23317 symtab
= create_mapped_symtab ();
23318 make_cleanup (cleanup_mapped_symtab
, symtab
);
23320 obstack_init (&addr_obstack
);
23321 make_cleanup_obstack_free (&addr_obstack
);
23323 obstack_init (&cu_list
);
23324 make_cleanup_obstack_free (&cu_list
);
23326 obstack_init (&types_cu_list
);
23327 make_cleanup_obstack_free (&types_cu_list
);
23329 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
23330 NULL
, xcalloc
, xfree
);
23331 make_cleanup_htab_delete (psyms_seen
);
23333 /* While we're scanning CU's create a table that maps a psymtab pointer
23334 (which is what addrmap records) to its index (which is what is recorded
23335 in the index file). This will later be needed to write the address
23337 cu_index_htab
= htab_create_alloc (100,
23338 hash_psymtab_cu_index
,
23339 eq_psymtab_cu_index
,
23340 NULL
, xcalloc
, xfree
);
23341 make_cleanup_htab_delete (cu_index_htab
);
23342 psymtab_cu_index_map
= XNEWVEC (struct psymtab_cu_index_map
,
23343 dwarf2_per_objfile
->n_comp_units
);
23344 make_cleanup (xfree
, psymtab_cu_index_map
);
23346 /* The CU list is already sorted, so we don't need to do additional
23347 work here. Also, the debug_types entries do not appear in
23348 all_comp_units, but only in their own hash table. */
23349 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
23351 struct dwarf2_per_cu_data
*per_cu
23352 = dwarf2_per_objfile
->all_comp_units
[i
];
23353 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
23355 struct psymtab_cu_index_map
*map
;
23358 /* CU of a shared file from 'dwz -m' may be unused by this main file.
23359 It may be referenced from a local scope but in such case it does not
23360 need to be present in .gdb_index. */
23361 if (psymtab
== NULL
)
23364 if (psymtab
->user
== NULL
)
23365 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
23367 map
= &psymtab_cu_index_map
[i
];
23368 map
->psymtab
= psymtab
;
23370 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
23371 gdb_assert (slot
!= NULL
);
23372 gdb_assert (*slot
== NULL
);
23375 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23376 per_cu
->offset
.sect_off
);
23377 obstack_grow (&cu_list
, val
, 8);
23378 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
23379 obstack_grow (&cu_list
, val
, 8);
23382 /* Dump the address map. */
23383 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
23385 /* Write out the .debug_type entries, if any. */
23386 if (dwarf2_per_objfile
->signatured_types
)
23388 struct signatured_type_index_data sig_data
;
23390 sig_data
.objfile
= objfile
;
23391 sig_data
.symtab
= symtab
;
23392 sig_data
.types_list
= &types_cu_list
;
23393 sig_data
.psyms_seen
= psyms_seen
;
23394 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
23395 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
23396 write_one_signatured_type
, &sig_data
);
23399 /* Now that we've processed all symbols we can shrink their cu_indices
23401 uniquify_cu_indices (symtab
);
23403 obstack_init (&constant_pool
);
23404 make_cleanup_obstack_free (&constant_pool
);
23405 obstack_init (&symtab_obstack
);
23406 make_cleanup_obstack_free (&symtab_obstack
);
23407 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
23409 obstack_init (&contents
);
23410 make_cleanup_obstack_free (&contents
);
23411 size_of_contents
= 6 * sizeof (offset_type
);
23412 total_len
= size_of_contents
;
23414 /* The version number. */
23415 val
= MAYBE_SWAP (8);
23416 obstack_grow (&contents
, &val
, sizeof (val
));
23418 /* The offset of the CU list from the start of the file. */
23419 val
= MAYBE_SWAP (total_len
);
23420 obstack_grow (&contents
, &val
, sizeof (val
));
23421 total_len
+= obstack_object_size (&cu_list
);
23423 /* The offset of the types CU list from the start of the file. */
23424 val
= MAYBE_SWAP (total_len
);
23425 obstack_grow (&contents
, &val
, sizeof (val
));
23426 total_len
+= obstack_object_size (&types_cu_list
);
23428 /* The offset of the address table from the start of the file. */
23429 val
= MAYBE_SWAP (total_len
);
23430 obstack_grow (&contents
, &val
, sizeof (val
));
23431 total_len
+= obstack_object_size (&addr_obstack
);
23433 /* The offset of the symbol table from the start of the file. */
23434 val
= MAYBE_SWAP (total_len
);
23435 obstack_grow (&contents
, &val
, sizeof (val
));
23436 total_len
+= obstack_object_size (&symtab_obstack
);
23438 /* The offset of the constant pool from the start of the file. */
23439 val
= MAYBE_SWAP (total_len
);
23440 obstack_grow (&contents
, &val
, sizeof (val
));
23441 total_len
+= obstack_object_size (&constant_pool
);
23443 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
23445 write_obstack (out_file
, &contents
);
23446 write_obstack (out_file
, &cu_list
);
23447 write_obstack (out_file
, &types_cu_list
);
23448 write_obstack (out_file
, &addr_obstack
);
23449 write_obstack (out_file
, &symtab_obstack
);
23450 write_obstack (out_file
, &constant_pool
);
23454 /* We want to keep the file, so we set cleanup_filename to NULL
23455 here. See unlink_if_set. */
23456 cleanup_filename
= NULL
;
23458 do_cleanups (cleanup
);
23461 /* Implementation of the `save gdb-index' command.
23463 Note that the file format used by this command is documented in the
23464 GDB manual. Any changes here must be documented there. */
23467 save_gdb_index_command (char *arg
, int from_tty
)
23469 struct objfile
*objfile
;
23472 error (_("usage: save gdb-index DIRECTORY"));
23474 ALL_OBJFILES (objfile
)
23478 /* If the objfile does not correspond to an actual file, skip it. */
23479 if (stat (objfile_name (objfile
), &st
) < 0)
23483 = (struct dwarf2_per_objfile
*) objfile_data (objfile
,
23484 dwarf2_objfile_data_key
);
23485 if (dwarf2_per_objfile
)
23490 write_psymtabs_to_index (objfile
, arg
);
23492 CATCH (except
, RETURN_MASK_ERROR
)
23494 exception_fprintf (gdb_stderr
, except
,
23495 _("Error while writing index for `%s': "),
23496 objfile_name (objfile
));
23505 int dwarf_always_disassemble
;
23508 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
23509 struct cmd_list_element
*c
, const char *value
)
23511 fprintf_filtered (file
,
23512 _("Whether to always disassemble "
23513 "DWARF expressions is %s.\n"),
23518 show_check_physname (struct ui_file
*file
, int from_tty
,
23519 struct cmd_list_element
*c
, const char *value
)
23521 fprintf_filtered (file
,
23522 _("Whether to check \"physname\" is %s.\n"),
23526 void _initialize_dwarf2_read (void);
23529 _initialize_dwarf2_read (void)
23531 struct cmd_list_element
*c
;
23533 dwarf2_objfile_data_key
23534 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
23536 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
23537 Set DWARF specific variables.\n\
23538 Configure DWARF variables such as the cache size"),
23539 &set_dwarf_cmdlist
, "maintenance set dwarf ",
23540 0/*allow-unknown*/, &maintenance_set_cmdlist
);
23542 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
23543 Show DWARF specific variables\n\
23544 Show DWARF variables such as the cache size"),
23545 &show_dwarf_cmdlist
, "maintenance show dwarf ",
23546 0/*allow-unknown*/, &maintenance_show_cmdlist
);
23548 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
23549 &dwarf_max_cache_age
, _("\
23550 Set the upper bound on the age of cached DWARF compilation units."), _("\
23551 Show the upper bound on the age of cached DWARF compilation units."), _("\
23552 A higher limit means that cached compilation units will be stored\n\
23553 in memory longer, and more total memory will be used. Zero disables\n\
23554 caching, which can slow down startup."),
23556 show_dwarf_max_cache_age
,
23557 &set_dwarf_cmdlist
,
23558 &show_dwarf_cmdlist
);
23560 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
23561 &dwarf_always_disassemble
, _("\
23562 Set whether `info address' always disassembles DWARF expressions."), _("\
23563 Show whether `info address' always disassembles DWARF expressions."), _("\
23564 When enabled, DWARF expressions are always printed in an assembly-like\n\
23565 syntax. When disabled, expressions will be printed in a more\n\
23566 conversational style, when possible."),
23568 show_dwarf_always_disassemble
,
23569 &set_dwarf_cmdlist
,
23570 &show_dwarf_cmdlist
);
23572 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
23573 Set debugging of the DWARF reader."), _("\
23574 Show debugging of the DWARF reader."), _("\
23575 When enabled (non-zero), debugging messages are printed during DWARF\n\
23576 reading and symtab expansion. A value of 1 (one) provides basic\n\
23577 information. A value greater than 1 provides more verbose information."),
23580 &setdebuglist
, &showdebuglist
);
23582 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
23583 Set debugging of the DWARF DIE reader."), _("\
23584 Show debugging of the DWARF DIE reader."), _("\
23585 When enabled (non-zero), DIEs are dumped after they are read in.\n\
23586 The value is the maximum depth to print."),
23589 &setdebuglist
, &showdebuglist
);
23591 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
23592 Set debugging of the dwarf line reader."), _("\
23593 Show debugging of the dwarf line reader."), _("\
23594 When enabled (non-zero), line number entries are dumped as they are read in.\n\
23595 A value of 1 (one) provides basic information.\n\
23596 A value greater than 1 provides more verbose information."),
23599 &setdebuglist
, &showdebuglist
);
23601 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
23602 Set cross-checking of \"physname\" code against demangler."), _("\
23603 Show cross-checking of \"physname\" code against demangler."), _("\
23604 When enabled, GDB's internal \"physname\" code is checked against\n\
23606 NULL
, show_check_physname
,
23607 &setdebuglist
, &showdebuglist
);
23609 add_setshow_boolean_cmd ("use-deprecated-index-sections",
23610 no_class
, &use_deprecated_index_sections
, _("\
23611 Set whether to use deprecated gdb_index sections."), _("\
23612 Show whether to use deprecated gdb_index sections."), _("\
23613 When enabled, deprecated .gdb_index sections are used anyway.\n\
23614 Normally they are ignored either because of a missing feature or\n\
23615 performance issue.\n\
23616 Warning: This option must be enabled before gdb reads the file."),
23619 &setlist
, &showlist
);
23621 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
23623 Save a gdb-index file.\n\
23624 Usage: save gdb-index DIRECTORY"),
23626 set_cmd_completer (c
, filename_completer
);
23628 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23629 &dwarf2_locexpr_funcs
);
23630 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23631 &dwarf2_loclist_funcs
);
23633 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23634 &dwarf2_block_frame_base_locexpr_funcs
);
23635 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23636 &dwarf2_block_frame_base_loclist_funcs
);