1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2015 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"
59 #include "completer.h"
64 #include "gdbcore.h" /* for gnutarget */
65 #include "gdb/gdb-index.h"
70 #include "filestuff.h"
74 #include <sys/types.h>
76 typedef struct symbol
*symbolp
;
79 /* When == 1, print basic high level tracing messages.
80 When > 1, be more verbose.
81 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
82 static unsigned int dwarf2_read_debug
= 0;
84 /* When non-zero, dump DIEs after they are read in. */
85 static unsigned int dwarf2_die_debug
= 0;
87 /* When non-zero, cross-check physname against demangler. */
88 static int check_physname
= 0;
90 /* When non-zero, do not reject deprecated .gdb_index sections. */
91 static int use_deprecated_index_sections
= 0;
93 static const struct objfile_data
*dwarf2_objfile_data_key
;
95 /* The "aclass" indices for various kinds of computed DWARF symbols. */
97 static int dwarf2_locexpr_index
;
98 static int dwarf2_loclist_index
;
99 static int dwarf2_locexpr_block_index
;
100 static int dwarf2_loclist_block_index
;
102 /* A descriptor for dwarf sections.
104 S.ASECTION, SIZE are typically initialized when the objfile is first
105 scanned. BUFFER, READIN are filled in later when the section is read.
106 If the section contained compressed data then SIZE is updated to record
107 the uncompressed size of the section.
109 DWP file format V2 introduces a wrinkle that is easiest to handle by
110 creating the concept of virtual sections contained within a real section.
111 In DWP V2 the sections of the input DWO files are concatenated together
112 into one section, but section offsets are kept relative to the original
114 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
115 the real section this "virtual" section is contained in, and BUFFER,SIZE
116 describe the virtual section. */
118 struct dwarf2_section_info
122 /* If this is a real section, the bfd section. */
124 /* If this is a virtual section, pointer to the containing ("real")
126 struct dwarf2_section_info
*containing_section
;
128 /* Pointer to section data, only valid if readin. */
129 const gdb_byte
*buffer
;
130 /* The size of the section, real or virtual. */
132 /* If this is a virtual section, the offset in the real section.
133 Only valid if is_virtual. */
134 bfd_size_type virtual_offset
;
135 /* True if we have tried to read this section. */
137 /* True if this is a virtual section, False otherwise.
138 This specifies which of s.asection and s.containing_section to use. */
142 typedef struct dwarf2_section_info dwarf2_section_info_def
;
143 DEF_VEC_O (dwarf2_section_info_def
);
145 /* All offsets in the index are of this type. It must be
146 architecture-independent. */
147 typedef uint32_t offset_type
;
149 DEF_VEC_I (offset_type
);
151 /* Ensure only legit values are used. */
152 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
154 gdb_assert ((unsigned int) (value) <= 1); \
155 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
158 /* Ensure only legit values are used. */
159 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
161 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
162 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
163 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
166 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
167 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
169 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
170 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
173 /* A description of the mapped index. The file format is described in
174 a comment by the code that writes the index. */
177 /* Index data format version. */
180 /* The total length of the buffer. */
183 /* A pointer to the address table data. */
184 const gdb_byte
*address_table
;
186 /* Size of the address table data in bytes. */
187 offset_type address_table_size
;
189 /* The symbol table, implemented as a hash table. */
190 const offset_type
*symbol_table
;
192 /* Size in slots, each slot is 2 offset_types. */
193 offset_type symbol_table_slots
;
195 /* A pointer to the constant pool. */
196 const char *constant_pool
;
199 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
200 DEF_VEC_P (dwarf2_per_cu_ptr
);
204 int nr_uniq_abbrev_tables
;
206 int nr_symtab_sharers
;
207 int nr_stmt_less_type_units
;
208 int nr_all_type_units_reallocs
;
211 /* Collection of data recorded per objfile.
212 This hangs off of dwarf2_objfile_data_key. */
214 struct dwarf2_per_objfile
216 struct dwarf2_section_info info
;
217 struct dwarf2_section_info abbrev
;
218 struct dwarf2_section_info line
;
219 struct dwarf2_section_info loc
;
220 struct dwarf2_section_info macinfo
;
221 struct dwarf2_section_info macro
;
222 struct dwarf2_section_info str
;
223 struct dwarf2_section_info ranges
;
224 struct dwarf2_section_info addr
;
225 struct dwarf2_section_info frame
;
226 struct dwarf2_section_info eh_frame
;
227 struct dwarf2_section_info gdb_index
;
229 VEC (dwarf2_section_info_def
) *types
;
232 struct objfile
*objfile
;
234 /* Table of all the compilation units. This is used to locate
235 the target compilation unit of a particular reference. */
236 struct dwarf2_per_cu_data
**all_comp_units
;
238 /* The number of compilation units in ALL_COMP_UNITS. */
241 /* The number of .debug_types-related CUs. */
244 /* The number of elements allocated in all_type_units.
245 If there are skeleton-less TUs, we add them to all_type_units lazily. */
246 int n_allocated_type_units
;
248 /* The .debug_types-related CUs (TUs).
249 This is stored in malloc space because we may realloc it. */
250 struct signatured_type
**all_type_units
;
252 /* Table of struct type_unit_group objects.
253 The hash key is the DW_AT_stmt_list value. */
254 htab_t type_unit_groups
;
256 /* A table mapping .debug_types signatures to its signatured_type entry.
257 This is NULL if the .debug_types section hasn't been read in yet. */
258 htab_t signatured_types
;
260 /* Type unit statistics, to see how well the scaling improvements
262 struct tu_stats tu_stats
;
264 /* A chain of compilation units that are currently read in, so that
265 they can be freed later. */
266 struct dwarf2_per_cu_data
*read_in_chain
;
268 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
269 This is NULL if the table hasn't been allocated yet. */
272 /* Non-zero if we've check for whether there is a DWP file. */
275 /* The DWP file if there is one, or NULL. */
276 struct dwp_file
*dwp_file
;
278 /* The shared '.dwz' file, if one exists. This is used when the
279 original data was compressed using 'dwz -m'. */
280 struct dwz_file
*dwz_file
;
282 /* A flag indicating wether this objfile has a section loaded at a
284 int has_section_at_zero
;
286 /* True if we are using the mapped index,
287 or we are faking it for OBJF_READNOW's sake. */
288 unsigned char using_index
;
290 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
291 struct mapped_index
*index_table
;
293 /* When using index_table, this keeps track of all quick_file_names entries.
294 TUs typically share line table entries with a CU, so we maintain a
295 separate table of all line table entries to support the sharing.
296 Note that while there can be way more TUs than CUs, we've already
297 sorted all the TUs into "type unit groups", grouped by their
298 DW_AT_stmt_list value. Therefore the only sharing done here is with a
299 CU and its associated TU group if there is one. */
300 htab_t quick_file_names_table
;
302 /* Set during partial symbol reading, to prevent queueing of full
304 int reading_partial_symbols
;
306 /* Table mapping type DIEs to their struct type *.
307 This is NULL if not allocated yet.
308 The mapping is done via (CU/TU + DIE offset) -> type. */
309 htab_t die_type_hash
;
311 /* The CUs we recently read. */
312 VEC (dwarf2_per_cu_ptr
) *just_read_cus
;
314 /* Table containing line_header indexed by offset and offset_in_dwz. */
315 htab_t line_header_hash
;
318 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
320 /* Default names of the debugging sections. */
322 /* Note that if the debugging section has been compressed, it might
323 have a name like .zdebug_info. */
325 static const struct dwarf2_debug_sections dwarf2_elf_names
=
327 { ".debug_info", ".zdebug_info" },
328 { ".debug_abbrev", ".zdebug_abbrev" },
329 { ".debug_line", ".zdebug_line" },
330 { ".debug_loc", ".zdebug_loc" },
331 { ".debug_macinfo", ".zdebug_macinfo" },
332 { ".debug_macro", ".zdebug_macro" },
333 { ".debug_str", ".zdebug_str" },
334 { ".debug_ranges", ".zdebug_ranges" },
335 { ".debug_types", ".zdebug_types" },
336 { ".debug_addr", ".zdebug_addr" },
337 { ".debug_frame", ".zdebug_frame" },
338 { ".eh_frame", NULL
},
339 { ".gdb_index", ".zgdb_index" },
343 /* List of DWO/DWP sections. */
345 static const struct dwop_section_names
347 struct dwarf2_section_names abbrev_dwo
;
348 struct dwarf2_section_names info_dwo
;
349 struct dwarf2_section_names line_dwo
;
350 struct dwarf2_section_names loc_dwo
;
351 struct dwarf2_section_names macinfo_dwo
;
352 struct dwarf2_section_names macro_dwo
;
353 struct dwarf2_section_names str_dwo
;
354 struct dwarf2_section_names str_offsets_dwo
;
355 struct dwarf2_section_names types_dwo
;
356 struct dwarf2_section_names cu_index
;
357 struct dwarf2_section_names tu_index
;
361 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
362 { ".debug_info.dwo", ".zdebug_info.dwo" },
363 { ".debug_line.dwo", ".zdebug_line.dwo" },
364 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
365 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
366 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
367 { ".debug_str.dwo", ".zdebug_str.dwo" },
368 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
369 { ".debug_types.dwo", ".zdebug_types.dwo" },
370 { ".debug_cu_index", ".zdebug_cu_index" },
371 { ".debug_tu_index", ".zdebug_tu_index" },
374 /* local data types */
376 /* The data in a compilation unit header, after target2host
377 translation, looks like this. */
378 struct comp_unit_head
382 unsigned char addr_size
;
383 unsigned char signed_addr_p
;
384 sect_offset abbrev_offset
;
386 /* Size of file offsets; either 4 or 8. */
387 unsigned int offset_size
;
389 /* Size of the length field; either 4 or 12. */
390 unsigned int initial_length_size
;
392 /* Offset to the first byte of this compilation unit header in the
393 .debug_info section, for resolving relative reference dies. */
396 /* Offset to first die in this cu from the start of the cu.
397 This will be the first byte following the compilation unit header. */
398 cu_offset first_die_offset
;
401 /* Type used for delaying computation of method physnames.
402 See comments for compute_delayed_physnames. */
403 struct delayed_method_info
405 /* The type to which the method is attached, i.e., its parent class. */
408 /* The index of the method in the type's function fieldlists. */
411 /* The index of the method in the fieldlist. */
414 /* The name of the DIE. */
417 /* The DIE associated with this method. */
418 struct die_info
*die
;
421 typedef struct delayed_method_info delayed_method_info
;
422 DEF_VEC_O (delayed_method_info
);
424 /* Internal state when decoding a particular compilation unit. */
427 /* The objfile containing this compilation unit. */
428 struct objfile
*objfile
;
430 /* The header of the compilation unit. */
431 struct comp_unit_head header
;
433 /* Base address of this compilation unit. */
434 CORE_ADDR base_address
;
436 /* Non-zero if base_address has been set. */
439 /* The language we are debugging. */
440 enum language language
;
441 const struct language_defn
*language_defn
;
443 const char *producer
;
445 /* The generic symbol table building routines have separate lists for
446 file scope symbols and all all other scopes (local scopes). So
447 we need to select the right one to pass to add_symbol_to_list().
448 We do it by keeping a pointer to the correct list in list_in_scope.
450 FIXME: The original dwarf code just treated the file scope as the
451 first local scope, and all other local scopes as nested local
452 scopes, and worked fine. Check to see if we really need to
453 distinguish these in buildsym.c. */
454 struct pending
**list_in_scope
;
456 /* The abbrev table for this CU.
457 Normally this points to the abbrev table in the objfile.
458 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
459 struct abbrev_table
*abbrev_table
;
461 /* Hash table holding all the loaded partial DIEs
462 with partial_die->offset.SECT_OFF as hash. */
465 /* Storage for things with the same lifetime as this read-in compilation
466 unit, including partial DIEs. */
467 struct obstack comp_unit_obstack
;
469 /* When multiple dwarf2_cu structures are living in memory, this field
470 chains them all together, so that they can be released efficiently.
471 We will probably also want a generation counter so that most-recently-used
472 compilation units are cached... */
473 struct dwarf2_per_cu_data
*read_in_chain
;
475 /* Backlink to our per_cu entry. */
476 struct dwarf2_per_cu_data
*per_cu
;
478 /* How many compilation units ago was this CU last referenced? */
481 /* A hash table of DIE cu_offset for following references with
482 die_info->offset.sect_off as hash. */
485 /* Full DIEs if read in. */
486 struct die_info
*dies
;
488 /* A set of pointers to dwarf2_per_cu_data objects for compilation
489 units referenced by this one. Only set during full symbol processing;
490 partial symbol tables do not have dependencies. */
493 /* Header data from the line table, during full symbol processing. */
494 struct line_header
*line_header
;
496 /* A list of methods which need to have physnames computed
497 after all type information has been read. */
498 VEC (delayed_method_info
) *method_list
;
500 /* To be copied to symtab->call_site_htab. */
501 htab_t call_site_htab
;
503 /* Non-NULL if this CU came from a DWO file.
504 There is an invariant here that is important to remember:
505 Except for attributes copied from the top level DIE in the "main"
506 (or "stub") file in preparation for reading the DWO file
507 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
508 Either there isn't a DWO file (in which case this is NULL and the point
509 is moot), or there is and either we're not going to read it (in which
510 case this is NULL) or there is and we are reading it (in which case this
512 struct dwo_unit
*dwo_unit
;
514 /* The DW_AT_addr_base attribute if present, zero otherwise
515 (zero is a valid value though).
516 Note this value comes from the Fission stub CU/TU's DIE. */
519 /* The DW_AT_ranges_base attribute if present, zero otherwise
520 (zero is a valid value though).
521 Note this value comes from the Fission stub CU/TU's DIE.
522 Also note that the value is zero in the non-DWO case so this value can
523 be used without needing to know whether DWO files are in use or not.
524 N.B. This does not apply to DW_AT_ranges appearing in
525 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
526 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
527 DW_AT_ranges_base *would* have to be applied, and we'd have to care
528 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
529 ULONGEST ranges_base
;
531 /* Mark used when releasing cached dies. */
532 unsigned int mark
: 1;
534 /* This CU references .debug_loc. See the symtab->locations_valid field.
535 This test is imperfect as there may exist optimized debug code not using
536 any location list and still facing inlining issues if handled as
537 unoptimized code. For a future better test see GCC PR other/32998. */
538 unsigned int has_loclist
: 1;
540 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
541 if all the producer_is_* fields are valid. This information is cached
542 because profiling CU expansion showed excessive time spent in
543 producer_is_gxx_lt_4_6. */
544 unsigned int checked_producer
: 1;
545 unsigned int producer_is_gxx_lt_4_6
: 1;
546 unsigned int producer_is_gcc_lt_4_3
: 1;
547 unsigned int producer_is_icc
: 1;
549 /* When set, the file that we're processing is known to have
550 debugging info for C++ namespaces. GCC 3.3.x did not produce
551 this information, but later versions do. */
553 unsigned int processing_has_namespace_info
: 1;
556 /* Persistent data held for a compilation unit, even when not
557 processing it. We put a pointer to this structure in the
558 read_symtab_private field of the psymtab. */
560 struct dwarf2_per_cu_data
562 /* The start offset and length of this compilation unit.
563 NOTE: Unlike comp_unit_head.length, this length includes
565 If the DIE refers to a DWO file, this is always of the original die,
570 /* Flag indicating this compilation unit will be read in before
571 any of the current compilation units are processed. */
572 unsigned int queued
: 1;
574 /* This flag will be set when reading partial DIEs if we need to load
575 absolutely all DIEs for this compilation unit, instead of just the ones
576 we think are interesting. It gets set if we look for a DIE in the
577 hash table and don't find it. */
578 unsigned int load_all_dies
: 1;
580 /* Non-zero if this CU is from .debug_types.
581 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
583 unsigned int is_debug_types
: 1;
585 /* Non-zero if this CU is from the .dwz file. */
586 unsigned int is_dwz
: 1;
588 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
589 This flag is only valid if is_debug_types is true.
590 We can't read a CU directly from a DWO file: There are required
591 attributes in the stub. */
592 unsigned int reading_dwo_directly
: 1;
594 /* Non-zero if the TU has been read.
595 This is used to assist the "Stay in DWO Optimization" for Fission:
596 When reading a DWO, it's faster to read TUs from the DWO instead of
597 fetching them from random other DWOs (due to comdat folding).
598 If the TU has already been read, the optimization is unnecessary
599 (and unwise - we don't want to change where gdb thinks the TU lives
601 This flag is only valid if is_debug_types is true. */
602 unsigned int tu_read
: 1;
604 /* The section this CU/TU lives in.
605 If the DIE refers to a DWO file, this is always the original die,
607 struct dwarf2_section_info
*section
;
609 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
610 of the CU cache it gets reset to NULL again. */
611 struct dwarf2_cu
*cu
;
613 /* The corresponding objfile.
614 Normally we can get the objfile from dwarf2_per_objfile.
615 However we can enter this file with just a "per_cu" handle. */
616 struct objfile
*objfile
;
618 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
619 is active. Otherwise, the 'psymtab' field is active. */
622 /* The partial symbol table associated with this compilation unit,
623 or NULL for unread partial units. */
624 struct partial_symtab
*psymtab
;
626 /* Data needed by the "quick" functions. */
627 struct dwarf2_per_cu_quick_data
*quick
;
630 /* The CUs we import using DW_TAG_imported_unit. This is filled in
631 while reading psymtabs, used to compute the psymtab dependencies,
632 and then cleared. Then it is filled in again while reading full
633 symbols, and only deleted when the objfile is destroyed.
635 This is also used to work around a difference between the way gold
636 generates .gdb_index version <=7 and the way gdb does. Arguably this
637 is a gold bug. For symbols coming from TUs, gold records in the index
638 the CU that includes the TU instead of the TU itself. This breaks
639 dw2_lookup_symbol: It assumes that if the index says symbol X lives
640 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
641 will find X. Alas TUs live in their own symtab, so after expanding CU Y
642 we need to look in TU Z to find X. Fortunately, this is akin to
643 DW_TAG_imported_unit, so we just use the same mechanism: For
644 .gdb_index version <=7 this also records the TUs that the CU referred
645 to. Concurrently with this change gdb was modified to emit version 8
646 indices so we only pay a price for gold generated indices.
647 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
648 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
651 /* Entry in the signatured_types hash table. */
653 struct signatured_type
655 /* The "per_cu" object of this type.
656 This struct is used iff per_cu.is_debug_types.
657 N.B.: This is the first member so that it's easy to convert pointers
659 struct dwarf2_per_cu_data per_cu
;
661 /* The type's signature. */
664 /* Offset in the TU of the type's DIE, as read from the TU header.
665 If this TU is a DWO stub and the definition lives in a DWO file
666 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
667 cu_offset type_offset_in_tu
;
669 /* Offset in the section of the type's DIE.
670 If the definition lives in a DWO file, this is the offset in the
671 .debug_types.dwo section.
672 The value is zero until the actual value is known.
673 Zero is otherwise not a valid section offset. */
674 sect_offset type_offset_in_section
;
676 /* Type units are grouped by their DW_AT_stmt_list entry so that they
677 can share them. This points to the containing symtab. */
678 struct type_unit_group
*type_unit_group
;
681 The first time we encounter this type we fully read it in and install it
682 in the symbol tables. Subsequent times we only need the type. */
685 /* Containing DWO unit.
686 This field is valid iff per_cu.reading_dwo_directly. */
687 struct dwo_unit
*dwo_unit
;
690 typedef struct signatured_type
*sig_type_ptr
;
691 DEF_VEC_P (sig_type_ptr
);
693 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
694 This includes type_unit_group and quick_file_names. */
696 struct stmt_list_hash
698 /* The DWO unit this table is from or NULL if there is none. */
699 struct dwo_unit
*dwo_unit
;
701 /* Offset in .debug_line or .debug_line.dwo. */
702 sect_offset line_offset
;
705 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
706 an object of this type. */
708 struct type_unit_group
710 /* dwarf2read.c's main "handle" on a TU symtab.
711 To simplify things we create an artificial CU that "includes" all the
712 type units using this stmt_list so that the rest of the code still has
713 a "per_cu" handle on the symtab.
714 This PER_CU is recognized by having no section. */
715 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
716 struct dwarf2_per_cu_data per_cu
;
718 /* The TUs that share this DW_AT_stmt_list entry.
719 This is added to while parsing type units to build partial symtabs,
720 and is deleted afterwards and not used again. */
721 VEC (sig_type_ptr
) *tus
;
723 /* The compunit symtab.
724 Type units in a group needn't all be defined in the same source file,
725 so we create an essentially anonymous symtab as the compunit symtab. */
726 struct compunit_symtab
*compunit_symtab
;
728 /* The data used to construct the hash key. */
729 struct stmt_list_hash hash
;
731 /* The number of symtabs from the line header.
732 The value here must match line_header.num_file_names. */
733 unsigned int num_symtabs
;
735 /* The symbol tables for this TU (obtained from the files listed in
737 WARNING: The order of entries here must match the order of entries
738 in the line header. After the first TU using this type_unit_group, the
739 line header for the subsequent TUs is recreated from this. This is done
740 because we need to use the same symtabs for each TU using the same
741 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
742 there's no guarantee the line header doesn't have duplicate entries. */
743 struct symtab
**symtabs
;
746 /* These sections are what may appear in a (real or virtual) DWO file. */
750 struct dwarf2_section_info abbrev
;
751 struct dwarf2_section_info line
;
752 struct dwarf2_section_info loc
;
753 struct dwarf2_section_info macinfo
;
754 struct dwarf2_section_info macro
;
755 struct dwarf2_section_info str
;
756 struct dwarf2_section_info str_offsets
;
757 /* In the case of a virtual DWO file, these two are unused. */
758 struct dwarf2_section_info info
;
759 VEC (dwarf2_section_info_def
) *types
;
762 /* CUs/TUs in DWP/DWO files. */
766 /* Backlink to the containing struct dwo_file. */
767 struct dwo_file
*dwo_file
;
769 /* The "id" that distinguishes this CU/TU.
770 .debug_info calls this "dwo_id", .debug_types calls this "signature".
771 Since signatures came first, we stick with it for consistency. */
774 /* The section this CU/TU lives in, in the DWO file. */
775 struct dwarf2_section_info
*section
;
777 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
781 /* For types, offset in the type's DIE of the type defined by this TU. */
782 cu_offset type_offset_in_tu
;
785 /* include/dwarf2.h defines the DWP section codes.
786 It defines a max value but it doesn't define a min value, which we
787 use for error checking, so provide one. */
789 enum dwp_v2_section_ids
794 /* Data for one DWO file.
796 This includes virtual DWO files (a virtual DWO file is a DWO file as it
797 appears in a DWP file). DWP files don't really have DWO files per se -
798 comdat folding of types "loses" the DWO file they came from, and from
799 a high level view DWP files appear to contain a mass of random types.
800 However, to maintain consistency with the non-DWP case we pretend DWP
801 files contain virtual DWO files, and we assign each TU with one virtual
802 DWO file (generally based on the line and abbrev section offsets -
803 a heuristic that seems to work in practice). */
807 /* The DW_AT_GNU_dwo_name attribute.
808 For virtual DWO files the name is constructed from the section offsets
809 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
810 from related CU+TUs. */
811 const char *dwo_name
;
813 /* The DW_AT_comp_dir attribute. */
814 const char *comp_dir
;
816 /* The bfd, when the file is open. Otherwise this is NULL.
817 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
820 /* The sections that make up this DWO file.
821 Remember that for virtual DWO files in DWP V2, these are virtual
822 sections (for lack of a better name). */
823 struct dwo_sections sections
;
825 /* The CU in the file.
826 We only support one because having more than one requires hacking the
827 dwo_name of each to match, which is highly unlikely to happen.
828 Doing this means all TUs can share comp_dir: We also assume that
829 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
832 /* Table of TUs in the file.
833 Each element is a struct dwo_unit. */
837 /* These sections are what may appear in a DWP file. */
841 /* These are used by both DWP version 1 and 2. */
842 struct dwarf2_section_info str
;
843 struct dwarf2_section_info cu_index
;
844 struct dwarf2_section_info tu_index
;
846 /* These are only used by DWP version 2 files.
847 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
848 sections are referenced by section number, and are not recorded here.
849 In DWP version 2 there is at most one copy of all these sections, each
850 section being (effectively) comprised of the concatenation of all of the
851 individual sections that exist in the version 1 format.
852 To keep the code simple we treat each of these concatenated pieces as a
853 section itself (a virtual section?). */
854 struct dwarf2_section_info abbrev
;
855 struct dwarf2_section_info info
;
856 struct dwarf2_section_info line
;
857 struct dwarf2_section_info loc
;
858 struct dwarf2_section_info macinfo
;
859 struct dwarf2_section_info macro
;
860 struct dwarf2_section_info str_offsets
;
861 struct dwarf2_section_info types
;
864 /* These sections are what may appear in a virtual DWO file in DWP version 1.
865 A virtual DWO file is a DWO file as it appears in a DWP file. */
867 struct virtual_v1_dwo_sections
869 struct dwarf2_section_info abbrev
;
870 struct dwarf2_section_info line
;
871 struct dwarf2_section_info loc
;
872 struct dwarf2_section_info macinfo
;
873 struct dwarf2_section_info macro
;
874 struct dwarf2_section_info str_offsets
;
875 /* Each DWP hash table entry records one CU or one TU.
876 That is recorded here, and copied to dwo_unit.section. */
877 struct dwarf2_section_info info_or_types
;
880 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
881 In version 2, the sections of the DWO files are concatenated together
882 and stored in one section of that name. Thus each ELF section contains
883 several "virtual" sections. */
885 struct virtual_v2_dwo_sections
887 bfd_size_type abbrev_offset
;
888 bfd_size_type abbrev_size
;
890 bfd_size_type line_offset
;
891 bfd_size_type line_size
;
893 bfd_size_type loc_offset
;
894 bfd_size_type loc_size
;
896 bfd_size_type macinfo_offset
;
897 bfd_size_type macinfo_size
;
899 bfd_size_type macro_offset
;
900 bfd_size_type macro_size
;
902 bfd_size_type str_offsets_offset
;
903 bfd_size_type str_offsets_size
;
905 /* Each DWP hash table entry records one CU or one TU.
906 That is recorded here, and copied to dwo_unit.section. */
907 bfd_size_type info_or_types_offset
;
908 bfd_size_type info_or_types_size
;
911 /* Contents of DWP hash tables. */
913 struct dwp_hash_table
915 uint32_t version
, nr_columns
;
916 uint32_t nr_units
, nr_slots
;
917 const gdb_byte
*hash_table
, *unit_table
;
922 const gdb_byte
*indices
;
926 /* This is indexed by column number and gives the id of the section
928 #define MAX_NR_V2_DWO_SECTIONS \
929 (1 /* .debug_info or .debug_types */ \
930 + 1 /* .debug_abbrev */ \
931 + 1 /* .debug_line */ \
932 + 1 /* .debug_loc */ \
933 + 1 /* .debug_str_offsets */ \
934 + 1 /* .debug_macro or .debug_macinfo */)
935 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
936 const gdb_byte
*offsets
;
937 const gdb_byte
*sizes
;
942 /* Data for one DWP file. */
946 /* Name of the file. */
949 /* File format version. */
955 /* Section info for this file. */
956 struct dwp_sections sections
;
958 /* Table of CUs in the file. */
959 const struct dwp_hash_table
*cus
;
961 /* Table of TUs in the file. */
962 const struct dwp_hash_table
*tus
;
964 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
968 /* Table to map ELF section numbers to their sections.
969 This is only needed for the DWP V1 file format. */
970 unsigned int num_sections
;
971 asection
**elf_sections
;
974 /* This represents a '.dwz' file. */
978 /* A dwz file can only contain a few sections. */
979 struct dwarf2_section_info abbrev
;
980 struct dwarf2_section_info info
;
981 struct dwarf2_section_info str
;
982 struct dwarf2_section_info line
;
983 struct dwarf2_section_info macro
;
984 struct dwarf2_section_info gdb_index
;
990 /* Struct used to pass misc. parameters to read_die_and_children, et
991 al. which are used for both .debug_info and .debug_types dies.
992 All parameters here are unchanging for the life of the call. This
993 struct exists to abstract away the constant parameters of die reading. */
995 struct die_reader_specs
997 /* The bfd of die_section. */
1000 /* The CU of the DIE we are parsing. */
1001 struct dwarf2_cu
*cu
;
1003 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1004 struct dwo_file
*dwo_file
;
1006 /* The section the die comes from.
1007 This is either .debug_info or .debug_types, or the .dwo variants. */
1008 struct dwarf2_section_info
*die_section
;
1010 /* die_section->buffer. */
1011 const gdb_byte
*buffer
;
1013 /* The end of the buffer. */
1014 const gdb_byte
*buffer_end
;
1016 /* The value of the DW_AT_comp_dir attribute. */
1017 const char *comp_dir
;
1020 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1021 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
1022 const gdb_byte
*info_ptr
,
1023 struct die_info
*comp_unit_die
,
1030 unsigned int dir_index
;
1031 unsigned int mod_time
;
1032 unsigned int length
;
1033 int included_p
; /* Non-zero if referenced by the Line Number Program. */
1034 struct symtab
*symtab
; /* The associated symbol table, if any. */
1037 /* The line number information for a compilation unit (found in the
1038 .debug_line section) begins with a "statement program header",
1039 which contains the following information. */
1042 /* Offset of line number information in .debug_line section. */
1045 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1046 unsigned offset_in_dwz
: 1;
1048 unsigned int total_length
;
1049 unsigned short version
;
1050 unsigned int header_length
;
1051 unsigned char minimum_instruction_length
;
1052 unsigned char maximum_ops_per_instruction
;
1053 unsigned char default_is_stmt
;
1055 unsigned char line_range
;
1056 unsigned char opcode_base
;
1058 /* standard_opcode_lengths[i] is the number of operands for the
1059 standard opcode whose value is i. This means that
1060 standard_opcode_lengths[0] is unused, and the last meaningful
1061 element is standard_opcode_lengths[opcode_base - 1]. */
1062 unsigned char *standard_opcode_lengths
;
1064 /* The include_directories table. NOTE! These strings are not
1065 allocated with xmalloc; instead, they are pointers into
1066 debug_line_buffer. If you try to free them, `free' will get
1068 unsigned int num_include_dirs
, include_dirs_size
;
1069 const char **include_dirs
;
1071 /* The file_names table. NOTE! These strings are not allocated
1072 with xmalloc; instead, they are pointers into debug_line_buffer.
1073 Don't try to free them directly. */
1074 unsigned int num_file_names
, file_names_size
;
1075 struct file_entry
*file_names
;
1077 /* The start and end of the statement program following this
1078 header. These point into dwarf2_per_objfile->line_buffer. */
1079 const gdb_byte
*statement_program_start
, *statement_program_end
;
1082 /* When we construct a partial symbol table entry we only
1083 need this much information. */
1084 struct partial_die_info
1086 /* Offset of this DIE. */
1089 /* DWARF-2 tag for this DIE. */
1090 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1092 /* Assorted flags describing the data found in this DIE. */
1093 unsigned int has_children
: 1;
1094 unsigned int is_external
: 1;
1095 unsigned int is_declaration
: 1;
1096 unsigned int has_type
: 1;
1097 unsigned int has_specification
: 1;
1098 unsigned int has_pc_info
: 1;
1099 unsigned int may_be_inlined
: 1;
1101 /* Flag set if the SCOPE field of this structure has been
1103 unsigned int scope_set
: 1;
1105 /* Flag set if the DIE has a byte_size attribute. */
1106 unsigned int has_byte_size
: 1;
1108 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1109 unsigned int has_const_value
: 1;
1111 /* Flag set if any of the DIE's children are template arguments. */
1112 unsigned int has_template_arguments
: 1;
1114 /* Flag set if fixup_partial_die has been called on this die. */
1115 unsigned int fixup_called
: 1;
1117 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1118 unsigned int is_dwz
: 1;
1120 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1121 unsigned int spec_is_dwz
: 1;
1123 /* The name of this DIE. Normally the value of DW_AT_name, but
1124 sometimes a default name for unnamed DIEs. */
1127 /* The linkage name, if present. */
1128 const char *linkage_name
;
1130 /* The scope to prepend to our children. This is generally
1131 allocated on the comp_unit_obstack, so will disappear
1132 when this compilation unit leaves the cache. */
1135 /* Some data associated with the partial DIE. The tag determines
1136 which field is live. */
1139 /* The location description associated with this DIE, if any. */
1140 struct dwarf_block
*locdesc
;
1141 /* The offset of an import, for DW_TAG_imported_unit. */
1145 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1149 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1150 DW_AT_sibling, if any. */
1151 /* NOTE: This member isn't strictly necessary, read_partial_die could
1152 return DW_AT_sibling values to its caller load_partial_dies. */
1153 const gdb_byte
*sibling
;
1155 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1156 DW_AT_specification (or DW_AT_abstract_origin or
1157 DW_AT_extension). */
1158 sect_offset spec_offset
;
1160 /* Pointers to this DIE's parent, first child, and next sibling,
1162 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
1165 /* This data structure holds the information of an abbrev. */
1168 unsigned int number
; /* number identifying abbrev */
1169 enum dwarf_tag tag
; /* dwarf tag */
1170 unsigned short has_children
; /* boolean */
1171 unsigned short num_attrs
; /* number of attributes */
1172 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1173 struct abbrev_info
*next
; /* next in chain */
1178 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1179 ENUM_BITFIELD(dwarf_form
) form
: 16;
1182 /* Size of abbrev_table.abbrev_hash_table. */
1183 #define ABBREV_HASH_SIZE 121
1185 /* Top level data structure to contain an abbreviation table. */
1189 /* Where the abbrev table came from.
1190 This is used as a sanity check when the table is used. */
1193 /* Storage for the abbrev table. */
1194 struct obstack abbrev_obstack
;
1196 /* Hash table of abbrevs.
1197 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1198 It could be statically allocated, but the previous code didn't so we
1200 struct abbrev_info
**abbrevs
;
1203 /* Attributes have a name and a value. */
1206 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1207 ENUM_BITFIELD(dwarf_form
) form
: 15;
1209 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1210 field should be in u.str (existing only for DW_STRING) but it is kept
1211 here for better struct attribute alignment. */
1212 unsigned int string_is_canonical
: 1;
1217 struct dwarf_block
*blk
;
1226 /* This data structure holds a complete die structure. */
1229 /* DWARF-2 tag for this DIE. */
1230 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1232 /* Number of attributes */
1233 unsigned char num_attrs
;
1235 /* True if we're presently building the full type name for the
1236 type derived from this DIE. */
1237 unsigned char building_fullname
: 1;
1239 /* True if this die is in process. PR 16581. */
1240 unsigned char in_process
: 1;
1243 unsigned int abbrev
;
1245 /* Offset in .debug_info or .debug_types section. */
1248 /* The dies in a compilation unit form an n-ary tree. PARENT
1249 points to this die's parent; CHILD points to the first child of
1250 this node; and all the children of a given node are chained
1251 together via their SIBLING fields. */
1252 struct die_info
*child
; /* Its first child, if any. */
1253 struct die_info
*sibling
; /* Its next sibling, if any. */
1254 struct die_info
*parent
; /* Its parent, if any. */
1256 /* An array of attributes, with NUM_ATTRS elements. There may be
1257 zero, but it's not common and zero-sized arrays are not
1258 sufficiently portable C. */
1259 struct attribute attrs
[1];
1262 /* Get at parts of an attribute structure. */
1264 #define DW_STRING(attr) ((attr)->u.str)
1265 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1266 #define DW_UNSND(attr) ((attr)->u.unsnd)
1267 #define DW_BLOCK(attr) ((attr)->u.blk)
1268 #define DW_SND(attr) ((attr)->u.snd)
1269 #define DW_ADDR(attr) ((attr)->u.addr)
1270 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1272 /* Blocks are a bunch of untyped bytes. */
1277 /* Valid only if SIZE is not zero. */
1278 const gdb_byte
*data
;
1281 #ifndef ATTR_ALLOC_CHUNK
1282 #define ATTR_ALLOC_CHUNK 4
1285 /* Allocate fields for structs, unions and enums in this size. */
1286 #ifndef DW_FIELD_ALLOC_CHUNK
1287 #define DW_FIELD_ALLOC_CHUNK 4
1290 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1291 but this would require a corresponding change in unpack_field_as_long
1293 static int bits_per_byte
= 8;
1297 struct nextfield
*next
;
1305 struct nextfnfield
*next
;
1306 struct fn_field fnfield
;
1313 struct nextfnfield
*head
;
1316 struct typedef_field_list
1318 struct typedef_field field
;
1319 struct typedef_field_list
*next
;
1322 /* The routines that read and process dies for a C struct or C++ class
1323 pass lists of data member fields and lists of member function fields
1324 in an instance of a field_info structure, as defined below. */
1327 /* List of data member and baseclasses fields. */
1328 struct nextfield
*fields
, *baseclasses
;
1330 /* Number of fields (including baseclasses). */
1333 /* Number of baseclasses. */
1336 /* Set if the accesibility of one of the fields is not public. */
1337 int non_public_fields
;
1339 /* Member function fields array, entries are allocated in the order they
1340 are encountered in the object file. */
1341 struct nextfnfield
*fnfields
;
1343 /* Member function fieldlist array, contains name of possibly overloaded
1344 member function, number of overloaded member functions and a pointer
1345 to the head of the member function field chain. */
1346 struct fnfieldlist
*fnfieldlists
;
1348 /* Number of entries in the fnfieldlists array. */
1351 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1352 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1353 struct typedef_field_list
*typedef_field_list
;
1354 unsigned typedef_field_list_count
;
1357 /* One item on the queue of compilation units to read in full symbols
1359 struct dwarf2_queue_item
1361 struct dwarf2_per_cu_data
*per_cu
;
1362 enum language pretend_language
;
1363 struct dwarf2_queue_item
*next
;
1366 /* The current queue. */
1367 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1369 /* Loaded secondary compilation units are kept in memory until they
1370 have not been referenced for the processing of this many
1371 compilation units. Set this to zero to disable caching. Cache
1372 sizes of up to at least twenty will improve startup time for
1373 typical inter-CU-reference binaries, at an obvious memory cost. */
1374 static int dwarf2_max_cache_age
= 5;
1376 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
1377 struct cmd_list_element
*c
, const char *value
)
1379 fprintf_filtered (file
, _("The upper bound on the age of cached "
1380 "dwarf2 compilation units is %s.\n"),
1384 /* local function prototypes */
1386 static const char *get_section_name (const struct dwarf2_section_info
*);
1388 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1390 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1392 static void dwarf2_find_base_address (struct die_info
*die
,
1393 struct dwarf2_cu
*cu
);
1395 static struct partial_symtab
*create_partial_symtab
1396 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1398 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1400 static void scan_partial_symbols (struct partial_die_info
*,
1401 CORE_ADDR
*, CORE_ADDR
*,
1402 int, struct dwarf2_cu
*);
1404 static void add_partial_symbol (struct partial_die_info
*,
1405 struct dwarf2_cu
*);
1407 static void add_partial_namespace (struct partial_die_info
*pdi
,
1408 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1409 int set_addrmap
, struct dwarf2_cu
*cu
);
1411 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1412 CORE_ADDR
*highpc
, int set_addrmap
,
1413 struct dwarf2_cu
*cu
);
1415 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1416 struct dwarf2_cu
*cu
);
1418 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1419 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1420 int need_pc
, struct dwarf2_cu
*cu
);
1422 static void dwarf2_read_symtab (struct partial_symtab
*,
1425 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1427 static struct abbrev_info
*abbrev_table_lookup_abbrev
1428 (const struct abbrev_table
*, unsigned int);
1430 static struct abbrev_table
*abbrev_table_read_table
1431 (struct dwarf2_section_info
*, sect_offset
);
1433 static void abbrev_table_free (struct abbrev_table
*);
1435 static void abbrev_table_free_cleanup (void *);
1437 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1438 struct dwarf2_section_info
*);
1440 static void dwarf2_free_abbrev_table (void *);
1442 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1444 static struct partial_die_info
*load_partial_dies
1445 (const struct die_reader_specs
*, const gdb_byte
*, int);
1447 static const gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1448 struct partial_die_info
*,
1449 struct abbrev_info
*,
1453 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1454 struct dwarf2_cu
*);
1456 static void fixup_partial_die (struct partial_die_info
*,
1457 struct dwarf2_cu
*);
1459 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1460 struct attribute
*, struct attr_abbrev
*,
1463 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1465 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1467 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1469 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1471 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1473 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1476 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1478 static LONGEST read_checked_initial_length_and_offset
1479 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1480 unsigned int *, unsigned int *);
1482 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1483 const struct comp_unit_head
*,
1486 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1488 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1491 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1493 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1495 static const char *read_indirect_string (bfd
*, const gdb_byte
*,
1496 const struct comp_unit_head
*,
1499 static const char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1501 static ULONGEST
read_unsigned_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1503 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1505 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1509 static const char *read_str_index (const struct die_reader_specs
*reader
,
1510 ULONGEST str_index
);
1512 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1514 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1515 struct dwarf2_cu
*);
1517 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1520 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1521 struct dwarf2_cu
*cu
);
1523 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1525 static struct die_info
*die_specification (struct die_info
*die
,
1526 struct dwarf2_cu
**);
1528 static void free_line_header (struct line_header
*lh
);
1530 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1531 struct dwarf2_cu
*cu
);
1533 static void dwarf_decode_lines (struct line_header
*, const char *,
1534 struct dwarf2_cu
*, struct partial_symtab
*,
1535 CORE_ADDR
, int decode_mapping
);
1537 static void dwarf2_start_subfile (const char *, const char *);
1539 static struct compunit_symtab
*dwarf2_start_symtab (struct dwarf2_cu
*,
1540 const char *, const char *,
1543 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1544 struct dwarf2_cu
*);
1546 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1547 struct dwarf2_cu
*, struct symbol
*);
1549 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1550 struct dwarf2_cu
*);
1552 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1555 struct obstack
*obstack
,
1556 struct dwarf2_cu
*cu
, LONGEST
*value
,
1557 const gdb_byte
**bytes
,
1558 struct dwarf2_locexpr_baton
**baton
);
1560 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1562 static int need_gnat_info (struct dwarf2_cu
*);
1564 static struct type
*die_descriptive_type (struct die_info
*,
1565 struct dwarf2_cu
*);
1567 static void set_descriptive_type (struct type
*, struct die_info
*,
1568 struct dwarf2_cu
*);
1570 static struct type
*die_containing_type (struct die_info
*,
1571 struct dwarf2_cu
*);
1573 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1574 struct dwarf2_cu
*);
1576 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1578 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1580 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1582 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1583 const char *suffix
, int physname
,
1584 struct dwarf2_cu
*cu
);
1586 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1588 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1590 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1592 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1594 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1596 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1597 struct dwarf2_cu
*, struct partial_symtab
*);
1599 static int dwarf2_get_pc_bounds (struct die_info
*,
1600 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1601 struct partial_symtab
*);
1603 static void get_scope_pc_bounds (struct die_info
*,
1604 CORE_ADDR
*, CORE_ADDR
*,
1605 struct dwarf2_cu
*);
1607 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1608 CORE_ADDR
, struct dwarf2_cu
*);
1610 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1611 struct dwarf2_cu
*);
1613 static void dwarf2_attach_fields_to_type (struct field_info
*,
1614 struct type
*, struct dwarf2_cu
*);
1616 static void dwarf2_add_member_fn (struct field_info
*,
1617 struct die_info
*, struct type
*,
1618 struct dwarf2_cu
*);
1620 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1622 struct dwarf2_cu
*);
1624 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1626 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1628 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1630 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1632 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1634 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1636 static struct type
*read_module_type (struct die_info
*die
,
1637 struct dwarf2_cu
*cu
);
1639 static const char *namespace_name (struct die_info
*die
,
1640 int *is_anonymous
, struct dwarf2_cu
*);
1642 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1644 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1646 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1647 struct dwarf2_cu
*);
1649 static struct die_info
*read_die_and_siblings_1
1650 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1653 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1654 const gdb_byte
*info_ptr
,
1655 const gdb_byte
**new_info_ptr
,
1656 struct die_info
*parent
);
1658 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1659 struct die_info
**, const gdb_byte
*,
1662 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1663 struct die_info
**, const gdb_byte
*,
1666 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1668 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1671 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1673 static const char *dwarf2_full_name (const char *name
,
1674 struct die_info
*die
,
1675 struct dwarf2_cu
*cu
);
1677 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1678 struct dwarf2_cu
*cu
);
1680 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1681 struct dwarf2_cu
**);
1683 static const char *dwarf_tag_name (unsigned int);
1685 static const char *dwarf_attr_name (unsigned int);
1687 static const char *dwarf_form_name (unsigned int);
1689 static char *dwarf_bool_name (unsigned int);
1691 static const char *dwarf_type_encoding_name (unsigned int);
1693 static struct die_info
*sibling_die (struct die_info
*);
1695 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1697 static void dump_die_for_error (struct die_info
*);
1699 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1702 /*static*/ void dump_die (struct die_info
*, int max_level
);
1704 static void store_in_ref_table (struct die_info
*,
1705 struct dwarf2_cu
*);
1707 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1709 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1711 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1712 const struct attribute
*,
1713 struct dwarf2_cu
**);
1715 static struct die_info
*follow_die_ref (struct die_info
*,
1716 const struct attribute
*,
1717 struct dwarf2_cu
**);
1719 static struct die_info
*follow_die_sig (struct die_info
*,
1720 const struct attribute
*,
1721 struct dwarf2_cu
**);
1723 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1724 struct dwarf2_cu
*);
1726 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1727 const struct attribute
*,
1728 struct dwarf2_cu
*);
1730 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1732 static void read_signatured_type (struct signatured_type
*);
1734 /* memory allocation interface */
1736 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1738 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1740 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1742 static int attr_form_is_block (const struct attribute
*);
1744 static int attr_form_is_section_offset (const struct attribute
*);
1746 static int attr_form_is_constant (const struct attribute
*);
1748 static int attr_form_is_ref (const struct attribute
*);
1750 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1751 struct dwarf2_loclist_baton
*baton
,
1752 const struct attribute
*attr
);
1754 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1756 struct dwarf2_cu
*cu
,
1759 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1760 const gdb_byte
*info_ptr
,
1761 struct abbrev_info
*abbrev
);
1763 static void free_stack_comp_unit (void *);
1765 static hashval_t
partial_die_hash (const void *item
);
1767 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1769 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1770 (sect_offset offset
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
1772 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1773 struct dwarf2_per_cu_data
*per_cu
);
1775 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1776 struct die_info
*comp_unit_die
,
1777 enum language pretend_language
);
1779 static void free_heap_comp_unit (void *);
1781 static void free_cached_comp_units (void *);
1783 static void age_cached_comp_units (void);
1785 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1787 static struct type
*set_die_type (struct die_info
*, struct type
*,
1788 struct dwarf2_cu
*);
1790 static void create_all_comp_units (struct objfile
*);
1792 static int create_all_type_units (struct objfile
*);
1794 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1797 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1800 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1803 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1804 struct dwarf2_per_cu_data
*);
1806 static void dwarf2_mark (struct dwarf2_cu
*);
1808 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1810 static struct type
*get_die_type_at_offset (sect_offset
,
1811 struct dwarf2_per_cu_data
*);
1813 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1815 static void dwarf2_release_queue (void *dummy
);
1817 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1818 enum language pretend_language
);
1820 static void process_queue (void);
1822 static void find_file_and_directory (struct die_info
*die
,
1823 struct dwarf2_cu
*cu
,
1824 const char **name
, const char **comp_dir
);
1826 static char *file_full_name (int file
, struct line_header
*lh
,
1827 const char *comp_dir
);
1829 static const gdb_byte
*read_and_check_comp_unit_head
1830 (struct comp_unit_head
*header
,
1831 struct dwarf2_section_info
*section
,
1832 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1833 int is_debug_types_section
);
1835 static void init_cutu_and_read_dies
1836 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1837 int use_existing_cu
, int keep
,
1838 die_reader_func_ftype
*die_reader_func
, void *data
);
1840 static void init_cutu_and_read_dies_simple
1841 (struct dwarf2_per_cu_data
*this_cu
,
1842 die_reader_func_ftype
*die_reader_func
, void *data
);
1844 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1846 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1848 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1849 (struct dwp_file
*dwp_file
, const char *comp_dir
,
1850 ULONGEST signature
, int is_debug_types
);
1852 static struct dwp_file
*get_dwp_file (void);
1854 static struct dwo_unit
*lookup_dwo_comp_unit
1855 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1857 static struct dwo_unit
*lookup_dwo_type_unit
1858 (struct signatured_type
*, const char *, const char *);
1860 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
1862 static void free_dwo_file_cleanup (void *);
1864 static void process_cu_includes (void);
1866 static void check_producer (struct dwarf2_cu
*cu
);
1868 static void free_line_header_voidp (void *arg
);
1870 /* Various complaints about symbol reading that don't abort the process. */
1873 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1875 complaint (&symfile_complaints
,
1876 _("statement list doesn't fit in .debug_line section"));
1880 dwarf2_debug_line_missing_file_complaint (void)
1882 complaint (&symfile_complaints
,
1883 _(".debug_line section has line data without a file"));
1887 dwarf2_debug_line_missing_end_sequence_complaint (void)
1889 complaint (&symfile_complaints
,
1890 _(".debug_line section has line "
1891 "program sequence without an end"));
1895 dwarf2_complex_location_expr_complaint (void)
1897 complaint (&symfile_complaints
, _("location expression too complex"));
1901 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1904 complaint (&symfile_complaints
,
1905 _("const value length mismatch for '%s', got %d, expected %d"),
1910 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1912 complaint (&symfile_complaints
,
1913 _("debug info runs off end of %s section"
1915 get_section_name (section
),
1916 get_section_file_name (section
));
1920 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1922 complaint (&symfile_complaints
,
1923 _("macro debug info contains a "
1924 "malformed macro definition:\n`%s'"),
1929 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1931 complaint (&symfile_complaints
,
1932 _("invalid attribute class or form for '%s' in '%s'"),
1936 /* Hash function for line_header_hash. */
1939 line_header_hash (const struct line_header
*ofs
)
1941 return ofs
->offset
.sect_off
^ ofs
->offset_in_dwz
;
1944 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1947 line_header_hash_voidp (const void *item
)
1949 const struct line_header
*ofs
= item
;
1951 return line_header_hash (ofs
);
1954 /* Equality function for line_header_hash. */
1957 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1959 const struct line_header
*ofs_lhs
= item_lhs
;
1960 const struct line_header
*ofs_rhs
= item_rhs
;
1962 return (ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
1963 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1969 /* Convert VALUE between big- and little-endian. */
1971 byte_swap (offset_type value
)
1975 result
= (value
& 0xff) << 24;
1976 result
|= (value
& 0xff00) << 8;
1977 result
|= (value
& 0xff0000) >> 8;
1978 result
|= (value
& 0xff000000) >> 24;
1982 #define MAYBE_SWAP(V) byte_swap (V)
1985 #define MAYBE_SWAP(V) (V)
1986 #endif /* WORDS_BIGENDIAN */
1988 /* Read the given attribute value as an address, taking the attribute's
1989 form into account. */
1992 attr_value_as_address (struct attribute
*attr
)
1996 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_GNU_addr_index
)
1998 /* Aside from a few clearly defined exceptions, attributes that
1999 contain an address must always be in DW_FORM_addr form.
2000 Unfortunately, some compilers happen to be violating this
2001 requirement by encoding addresses using other forms, such
2002 as DW_FORM_data4 for example. For those broken compilers,
2003 we try to do our best, without any guarantee of success,
2004 to interpret the address correctly. It would also be nice
2005 to generate a complaint, but that would require us to maintain
2006 a list of legitimate cases where a non-address form is allowed,
2007 as well as update callers to pass in at least the CU's DWARF
2008 version. This is more overhead than what we're willing to
2009 expand for a pretty rare case. */
2010 addr
= DW_UNSND (attr
);
2013 addr
= DW_ADDR (attr
);
2018 /* The suffix for an index file. */
2019 #define INDEX_SUFFIX ".gdb-index"
2021 /* Try to locate the sections we need for DWARF 2 debugging
2022 information and return true if we have enough to do something.
2023 NAMES points to the dwarf2 section names, or is NULL if the standard
2024 ELF names are used. */
2027 dwarf2_has_info (struct objfile
*objfile
,
2028 const struct dwarf2_debug_sections
*names
)
2030 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2031 if (!dwarf2_per_objfile
)
2033 /* Initialize per-objfile state. */
2034 struct dwarf2_per_objfile
*data
2035 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
2037 memset (data
, 0, sizeof (*data
));
2038 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
2039 dwarf2_per_objfile
= data
;
2041 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
2043 dwarf2_per_objfile
->objfile
= objfile
;
2045 return (!dwarf2_per_objfile
->info
.is_virtual
2046 && dwarf2_per_objfile
->info
.s
.asection
!= NULL
2047 && !dwarf2_per_objfile
->abbrev
.is_virtual
2048 && dwarf2_per_objfile
->abbrev
.s
.asection
!= NULL
);
2051 /* Return the containing section of virtual section SECTION. */
2053 static struct dwarf2_section_info
*
2054 get_containing_section (const struct dwarf2_section_info
*section
)
2056 gdb_assert (section
->is_virtual
);
2057 return section
->s
.containing_section
;
2060 /* Return the bfd owner of SECTION. */
2063 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2065 if (section
->is_virtual
)
2067 section
= get_containing_section (section
);
2068 gdb_assert (!section
->is_virtual
);
2070 return section
->s
.asection
->owner
;
2073 /* Return the bfd section of SECTION.
2074 Returns NULL if the section is not present. */
2077 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2079 if (section
->is_virtual
)
2081 section
= get_containing_section (section
);
2082 gdb_assert (!section
->is_virtual
);
2084 return section
->s
.asection
;
2087 /* Return the name of SECTION. */
2090 get_section_name (const struct dwarf2_section_info
*section
)
2092 asection
*sectp
= get_section_bfd_section (section
);
2094 gdb_assert (sectp
!= NULL
);
2095 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2098 /* Return the name of the file SECTION is in. */
2101 get_section_file_name (const struct dwarf2_section_info
*section
)
2103 bfd
*abfd
= get_section_bfd_owner (section
);
2105 return bfd_get_filename (abfd
);
2108 /* Return the id of SECTION.
2109 Returns 0 if SECTION doesn't exist. */
2112 get_section_id (const struct dwarf2_section_info
*section
)
2114 asection
*sectp
= get_section_bfd_section (section
);
2121 /* Return the flags of SECTION.
2122 SECTION (or containing section if this is a virtual section) must exist. */
2125 get_section_flags (const struct dwarf2_section_info
*section
)
2127 asection
*sectp
= get_section_bfd_section (section
);
2129 gdb_assert (sectp
!= NULL
);
2130 return bfd_get_section_flags (sectp
->owner
, sectp
);
2133 /* When loading sections, we look either for uncompressed section or for
2134 compressed section names. */
2137 section_is_p (const char *section_name
,
2138 const struct dwarf2_section_names
*names
)
2140 if (names
->normal
!= NULL
2141 && strcmp (section_name
, names
->normal
) == 0)
2143 if (names
->compressed
!= NULL
2144 && strcmp (section_name
, names
->compressed
) == 0)
2149 /* This function is mapped across the sections and remembers the
2150 offset and size of each of the debugging sections we are interested
2154 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
2156 const struct dwarf2_debug_sections
*names
;
2157 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2160 names
= &dwarf2_elf_names
;
2162 names
= (const struct dwarf2_debug_sections
*) vnames
;
2164 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2167 else if (section_is_p (sectp
->name
, &names
->info
))
2169 dwarf2_per_objfile
->info
.s
.asection
= sectp
;
2170 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
2172 else if (section_is_p (sectp
->name
, &names
->abbrev
))
2174 dwarf2_per_objfile
->abbrev
.s
.asection
= sectp
;
2175 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
2177 else if (section_is_p (sectp
->name
, &names
->line
))
2179 dwarf2_per_objfile
->line
.s
.asection
= sectp
;
2180 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
2182 else if (section_is_p (sectp
->name
, &names
->loc
))
2184 dwarf2_per_objfile
->loc
.s
.asection
= sectp
;
2185 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
2187 else if (section_is_p (sectp
->name
, &names
->macinfo
))
2189 dwarf2_per_objfile
->macinfo
.s
.asection
= sectp
;
2190 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
2192 else if (section_is_p (sectp
->name
, &names
->macro
))
2194 dwarf2_per_objfile
->macro
.s
.asection
= sectp
;
2195 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
2197 else if (section_is_p (sectp
->name
, &names
->str
))
2199 dwarf2_per_objfile
->str
.s
.asection
= sectp
;
2200 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
2202 else if (section_is_p (sectp
->name
, &names
->addr
))
2204 dwarf2_per_objfile
->addr
.s
.asection
= sectp
;
2205 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
2207 else if (section_is_p (sectp
->name
, &names
->frame
))
2209 dwarf2_per_objfile
->frame
.s
.asection
= sectp
;
2210 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
2212 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
2214 dwarf2_per_objfile
->eh_frame
.s
.asection
= sectp
;
2215 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
2217 else if (section_is_p (sectp
->name
, &names
->ranges
))
2219 dwarf2_per_objfile
->ranges
.s
.asection
= sectp
;
2220 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
2222 else if (section_is_p (sectp
->name
, &names
->types
))
2224 struct dwarf2_section_info type_section
;
2226 memset (&type_section
, 0, sizeof (type_section
));
2227 type_section
.s
.asection
= sectp
;
2228 type_section
.size
= bfd_get_section_size (sectp
);
2230 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
2233 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
2235 dwarf2_per_objfile
->gdb_index
.s
.asection
= sectp
;
2236 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
2239 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
2240 && bfd_section_vma (abfd
, sectp
) == 0)
2241 dwarf2_per_objfile
->has_section_at_zero
= 1;
2244 /* A helper function that decides whether a section is empty,
2248 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2250 if (section
->is_virtual
)
2251 return section
->size
== 0;
2252 return section
->s
.asection
== NULL
|| section
->size
== 0;
2255 /* Read the contents of the section INFO.
2256 OBJFILE is the main object file, but not necessarily the file where
2257 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2259 If the section is compressed, uncompress it before returning. */
2262 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
2266 gdb_byte
*buf
, *retbuf
;
2270 info
->buffer
= NULL
;
2273 if (dwarf2_section_empty_p (info
))
2276 sectp
= get_section_bfd_section (info
);
2278 /* If this is a virtual section we need to read in the real one first. */
2279 if (info
->is_virtual
)
2281 struct dwarf2_section_info
*containing_section
=
2282 get_containing_section (info
);
2284 gdb_assert (sectp
!= NULL
);
2285 if ((sectp
->flags
& SEC_RELOC
) != 0)
2287 error (_("Dwarf Error: DWP format V2 with relocations is not"
2288 " supported in section %s [in module %s]"),
2289 get_section_name (info
), get_section_file_name (info
));
2291 dwarf2_read_section (objfile
, containing_section
);
2292 /* Other code should have already caught virtual sections that don't
2294 gdb_assert (info
->virtual_offset
+ info
->size
2295 <= containing_section
->size
);
2296 /* If the real section is empty or there was a problem reading the
2297 section we shouldn't get here. */
2298 gdb_assert (containing_section
->buffer
!= NULL
);
2299 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2303 /* If the section has relocations, we must read it ourselves.
2304 Otherwise we attach it to the BFD. */
2305 if ((sectp
->flags
& SEC_RELOC
) == 0)
2307 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2311 buf
= obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2314 /* When debugging .o files, we may need to apply relocations; see
2315 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2316 We never compress sections in .o files, so we only need to
2317 try this when the section is not compressed. */
2318 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2321 info
->buffer
= retbuf
;
2325 abfd
= get_section_bfd_owner (info
);
2326 gdb_assert (abfd
!= NULL
);
2328 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2329 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2331 error (_("Dwarf Error: Can't read DWARF data"
2332 " in section %s [in module %s]"),
2333 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2337 /* A helper function that returns the size of a section in a safe way.
2338 If you are positive that the section has been read before using the
2339 size, then it is safe to refer to the dwarf2_section_info object's
2340 "size" field directly. In other cases, you must call this
2341 function, because for compressed sections the size field is not set
2342 correctly until the section has been read. */
2344 static bfd_size_type
2345 dwarf2_section_size (struct objfile
*objfile
,
2346 struct dwarf2_section_info
*info
)
2349 dwarf2_read_section (objfile
, info
);
2353 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2357 dwarf2_get_section_info (struct objfile
*objfile
,
2358 enum dwarf2_section_enum sect
,
2359 asection
**sectp
, const gdb_byte
**bufp
,
2360 bfd_size_type
*sizep
)
2362 struct dwarf2_per_objfile
*data
2363 = objfile_data (objfile
, dwarf2_objfile_data_key
);
2364 struct dwarf2_section_info
*info
;
2366 /* We may see an objfile without any DWARF, in which case we just
2377 case DWARF2_DEBUG_FRAME
:
2378 info
= &data
->frame
;
2380 case DWARF2_EH_FRAME
:
2381 info
= &data
->eh_frame
;
2384 gdb_assert_not_reached ("unexpected section");
2387 dwarf2_read_section (objfile
, info
);
2389 *sectp
= get_section_bfd_section (info
);
2390 *bufp
= info
->buffer
;
2391 *sizep
= info
->size
;
2394 /* A helper function to find the sections for a .dwz file. */
2397 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2399 struct dwz_file
*dwz_file
= arg
;
2401 /* Note that we only support the standard ELF names, because .dwz
2402 is ELF-only (at the time of writing). */
2403 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2405 dwz_file
->abbrev
.s
.asection
= sectp
;
2406 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2408 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2410 dwz_file
->info
.s
.asection
= sectp
;
2411 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2413 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2415 dwz_file
->str
.s
.asection
= sectp
;
2416 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2418 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2420 dwz_file
->line
.s
.asection
= sectp
;
2421 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2423 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2425 dwz_file
->macro
.s
.asection
= sectp
;
2426 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2428 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2430 dwz_file
->gdb_index
.s
.asection
= sectp
;
2431 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2435 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2436 there is no .gnu_debugaltlink section in the file. Error if there
2437 is such a section but the file cannot be found. */
2439 static struct dwz_file
*
2440 dwarf2_get_dwz_file (void)
2444 struct cleanup
*cleanup
;
2445 const char *filename
;
2446 struct dwz_file
*result
;
2447 bfd_size_type buildid_len_arg
;
2451 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2452 return dwarf2_per_objfile
->dwz_file
;
2454 bfd_set_error (bfd_error_no_error
);
2455 data
= bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2456 &buildid_len_arg
, &buildid
);
2459 if (bfd_get_error () == bfd_error_no_error
)
2461 error (_("could not read '.gnu_debugaltlink' section: %s"),
2462 bfd_errmsg (bfd_get_error ()));
2464 cleanup
= make_cleanup (xfree
, data
);
2465 make_cleanup (xfree
, buildid
);
2467 buildid_len
= (size_t) buildid_len_arg
;
2469 filename
= (const char *) data
;
2470 if (!IS_ABSOLUTE_PATH (filename
))
2472 char *abs
= gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2475 make_cleanup (xfree
, abs
);
2476 abs
= ldirname (abs
);
2477 make_cleanup (xfree
, abs
);
2479 rel
= concat (abs
, SLASH_STRING
, filename
, (char *) NULL
);
2480 make_cleanup (xfree
, rel
);
2484 /* First try the file name given in the section. If that doesn't
2485 work, try to use the build-id instead. */
2486 dwz_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2487 if (dwz_bfd
!= NULL
)
2489 if (!build_id_verify (dwz_bfd
, buildid_len
, buildid
))
2491 gdb_bfd_unref (dwz_bfd
);
2496 if (dwz_bfd
== NULL
)
2497 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2499 if (dwz_bfd
== NULL
)
2500 error (_("could not find '.gnu_debugaltlink' file for %s"),
2501 objfile_name (dwarf2_per_objfile
->objfile
));
2503 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2505 result
->dwz_bfd
= dwz_bfd
;
2507 bfd_map_over_sections (dwz_bfd
, locate_dwz_sections
, result
);
2509 do_cleanups (cleanup
);
2511 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, dwz_bfd
);
2512 dwarf2_per_objfile
->dwz_file
= result
;
2516 /* DWARF quick_symbols_functions support. */
2518 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2519 unique line tables, so we maintain a separate table of all .debug_line
2520 derived entries to support the sharing.
2521 All the quick functions need is the list of file names. We discard the
2522 line_header when we're done and don't need to record it here. */
2523 struct quick_file_names
2525 /* The data used to construct the hash key. */
2526 struct stmt_list_hash hash
;
2528 /* The number of entries in file_names, real_names. */
2529 unsigned int num_file_names
;
2531 /* The file names from the line table, after being run through
2533 const char **file_names
;
2535 /* The file names from the line table after being run through
2536 gdb_realpath. These are computed lazily. */
2537 const char **real_names
;
2540 /* When using the index (and thus not using psymtabs), each CU has an
2541 object of this type. This is used to hold information needed by
2542 the various "quick" methods. */
2543 struct dwarf2_per_cu_quick_data
2545 /* The file table. This can be NULL if there was no file table
2546 or it's currently not read in.
2547 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2548 struct quick_file_names
*file_names
;
2550 /* The corresponding symbol table. This is NULL if symbols for this
2551 CU have not yet been read. */
2552 struct compunit_symtab
*compunit_symtab
;
2554 /* A temporary mark bit used when iterating over all CUs in
2555 expand_symtabs_matching. */
2556 unsigned int mark
: 1;
2558 /* True if we've tried to read the file table and found there isn't one.
2559 There will be no point in trying to read it again next time. */
2560 unsigned int no_file_data
: 1;
2563 /* Utility hash function for a stmt_list_hash. */
2566 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2570 if (stmt_list_hash
->dwo_unit
!= NULL
)
2571 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2572 v
+= stmt_list_hash
->line_offset
.sect_off
;
2576 /* Utility equality function for a stmt_list_hash. */
2579 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2580 const struct stmt_list_hash
*rhs
)
2582 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2584 if (lhs
->dwo_unit
!= NULL
2585 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2588 return lhs
->line_offset
.sect_off
== rhs
->line_offset
.sect_off
;
2591 /* Hash function for a quick_file_names. */
2594 hash_file_name_entry (const void *e
)
2596 const struct quick_file_names
*file_data
= e
;
2598 return hash_stmt_list_entry (&file_data
->hash
);
2601 /* Equality function for a quick_file_names. */
2604 eq_file_name_entry (const void *a
, const void *b
)
2606 const struct quick_file_names
*ea
= a
;
2607 const struct quick_file_names
*eb
= b
;
2609 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2612 /* Delete function for a quick_file_names. */
2615 delete_file_name_entry (void *e
)
2617 struct quick_file_names
*file_data
= e
;
2620 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2622 xfree ((void*) file_data
->file_names
[i
]);
2623 if (file_data
->real_names
)
2624 xfree ((void*) file_data
->real_names
[i
]);
2627 /* The space for the struct itself lives on objfile_obstack,
2628 so we don't free it here. */
2631 /* Create a quick_file_names hash table. */
2634 create_quick_file_names_table (unsigned int nr_initial_entries
)
2636 return htab_create_alloc (nr_initial_entries
,
2637 hash_file_name_entry
, eq_file_name_entry
,
2638 delete_file_name_entry
, xcalloc
, xfree
);
2641 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2642 have to be created afterwards. You should call age_cached_comp_units after
2643 processing PER_CU->CU. dw2_setup must have been already called. */
2646 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2648 if (per_cu
->is_debug_types
)
2649 load_full_type_unit (per_cu
);
2651 load_full_comp_unit (per_cu
, language_minimal
);
2653 gdb_assert (per_cu
->cu
!= NULL
);
2655 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2658 /* Read in the symbols for PER_CU. */
2661 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2663 struct cleanup
*back_to
;
2665 /* Skip type_unit_groups, reading the type units they contain
2666 is handled elsewhere. */
2667 if (IS_TYPE_UNIT_GROUP (per_cu
))
2670 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2672 if (dwarf2_per_objfile
->using_index
2673 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2674 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2676 queue_comp_unit (per_cu
, language_minimal
);
2679 /* If we just loaded a CU from a DWO, and we're working with an index
2680 that may badly handle TUs, load all the TUs in that DWO as well.
2681 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2682 if (!per_cu
->is_debug_types
2683 && per_cu
->cu
->dwo_unit
!= NULL
2684 && dwarf2_per_objfile
->index_table
!= NULL
2685 && dwarf2_per_objfile
->index_table
->version
<= 7
2686 /* DWP files aren't supported yet. */
2687 && get_dwp_file () == NULL
)
2688 queue_and_load_all_dwo_tus (per_cu
);
2693 /* Age the cache, releasing compilation units that have not
2694 been used recently. */
2695 age_cached_comp_units ();
2697 do_cleanups (back_to
);
2700 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2701 the objfile from which this CU came. Returns the resulting symbol
2704 static struct compunit_symtab
*
2705 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2707 gdb_assert (dwarf2_per_objfile
->using_index
);
2708 if (!per_cu
->v
.quick
->compunit_symtab
)
2710 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2711 increment_reading_symtab ();
2712 dw2_do_instantiate_symtab (per_cu
);
2713 process_cu_includes ();
2714 do_cleanups (back_to
);
2717 return per_cu
->v
.quick
->compunit_symtab
;
2720 /* Return the CU/TU given its index.
2722 This is intended for loops like:
2724 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2725 + dwarf2_per_objfile->n_type_units); ++i)
2727 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
2733 static struct dwarf2_per_cu_data
*
2734 dw2_get_cutu (int index
)
2736 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2738 index
-= dwarf2_per_objfile
->n_comp_units
;
2739 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
2740 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
2743 return dwarf2_per_objfile
->all_comp_units
[index
];
2746 /* Return the CU given its index.
2747 This differs from dw2_get_cutu in that it's for when you know INDEX
2750 static struct dwarf2_per_cu_data
*
2751 dw2_get_cu (int index
)
2753 gdb_assert (index
>= 0 && index
< dwarf2_per_objfile
->n_comp_units
);
2755 return dwarf2_per_objfile
->all_comp_units
[index
];
2758 /* A helper for create_cus_from_index that handles a given list of
2762 create_cus_from_index_list (struct objfile
*objfile
,
2763 const gdb_byte
*cu_list
, offset_type n_elements
,
2764 struct dwarf2_section_info
*section
,
2770 for (i
= 0; i
< n_elements
; i
+= 2)
2772 struct dwarf2_per_cu_data
*the_cu
;
2773 ULONGEST offset
, length
;
2775 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2776 offset
= extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2777 length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2780 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2781 struct dwarf2_per_cu_data
);
2782 the_cu
->offset
.sect_off
= offset
;
2783 the_cu
->length
= length
;
2784 the_cu
->objfile
= objfile
;
2785 the_cu
->section
= section
;
2786 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2787 struct dwarf2_per_cu_quick_data
);
2788 the_cu
->is_dwz
= is_dwz
;
2789 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
2793 /* Read the CU list from the mapped index, and use it to create all
2794 the CU objects for this objfile. */
2797 create_cus_from_index (struct objfile
*objfile
,
2798 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2799 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2801 struct dwz_file
*dwz
;
2803 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
2804 dwarf2_per_objfile
->all_comp_units
2805 = obstack_alloc (&objfile
->objfile_obstack
,
2806 dwarf2_per_objfile
->n_comp_units
2807 * sizeof (struct dwarf2_per_cu_data
*));
2809 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
2810 &dwarf2_per_objfile
->info
, 0, 0);
2812 if (dwz_elements
== 0)
2815 dwz
= dwarf2_get_dwz_file ();
2816 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
2817 cu_list_elements
/ 2);
2820 /* Create the signatured type hash table from the index. */
2823 create_signatured_type_table_from_index (struct objfile
*objfile
,
2824 struct dwarf2_section_info
*section
,
2825 const gdb_byte
*bytes
,
2826 offset_type elements
)
2829 htab_t sig_types_hash
;
2831 dwarf2_per_objfile
->n_type_units
2832 = dwarf2_per_objfile
->n_allocated_type_units
2834 dwarf2_per_objfile
->all_type_units
2835 = xmalloc (dwarf2_per_objfile
->n_type_units
2836 * sizeof (struct signatured_type
*));
2838 sig_types_hash
= allocate_signatured_type_table (objfile
);
2840 for (i
= 0; i
< elements
; i
+= 3)
2842 struct signatured_type
*sig_type
;
2843 ULONGEST offset
, type_offset_in_tu
, signature
;
2846 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2847 offset
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2848 type_offset_in_tu
= extract_unsigned_integer (bytes
+ 8, 8,
2850 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2853 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2854 struct signatured_type
);
2855 sig_type
->signature
= signature
;
2856 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2857 sig_type
->per_cu
.is_debug_types
= 1;
2858 sig_type
->per_cu
.section
= section
;
2859 sig_type
->per_cu
.offset
.sect_off
= offset
;
2860 sig_type
->per_cu
.objfile
= objfile
;
2861 sig_type
->per_cu
.v
.quick
2862 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2863 struct dwarf2_per_cu_quick_data
);
2865 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2868 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
2871 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2874 /* Read the address map data from the mapped index, and use it to
2875 populate the objfile's psymtabs_addrmap. */
2878 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2880 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2881 const gdb_byte
*iter
, *end
;
2882 struct obstack temp_obstack
;
2883 struct addrmap
*mutable_map
;
2884 struct cleanup
*cleanup
;
2887 obstack_init (&temp_obstack
);
2888 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2889 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2891 iter
= index
->address_table
;
2892 end
= iter
+ index
->address_table_size
;
2894 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2898 ULONGEST hi
, lo
, cu_index
;
2899 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2901 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2903 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2908 complaint (&symfile_complaints
,
2909 _(".gdb_index address table has invalid range (%s - %s)"),
2910 hex_string (lo
), hex_string (hi
));
2914 if (cu_index
>= dwarf2_per_objfile
->n_comp_units
)
2916 complaint (&symfile_complaints
,
2917 _(".gdb_index address table has invalid CU number %u"),
2918 (unsigned) cu_index
);
2922 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
);
2923 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
);
2924 addrmap_set_empty (mutable_map
, lo
, hi
- 1, dw2_get_cutu (cu_index
));
2927 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2928 &objfile
->objfile_obstack
);
2929 do_cleanups (cleanup
);
2932 /* The hash function for strings in the mapped index. This is the same as
2933 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2934 implementation. This is necessary because the hash function is tied to the
2935 format of the mapped index file. The hash values do not have to match with
2938 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2941 mapped_index_string_hash (int index_version
, const void *p
)
2943 const unsigned char *str
= (const unsigned char *) p
;
2947 while ((c
= *str
++) != 0)
2949 if (index_version
>= 5)
2951 r
= r
* 67 + c
- 113;
2957 /* Find a slot in the mapped index INDEX for the object named NAME.
2958 If NAME is found, set *VEC_OUT to point to the CU vector in the
2959 constant pool and return 1. If NAME cannot be found, return 0. */
2962 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2963 offset_type
**vec_out
)
2965 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2967 offset_type slot
, step
;
2968 int (*cmp
) (const char *, const char *);
2970 if (current_language
->la_language
== language_cplus
2971 || current_language
->la_language
== language_java
2972 || current_language
->la_language
== language_fortran
)
2974 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2977 if (strchr (name
, '(') != NULL
)
2979 char *without_params
= cp_remove_params (name
);
2981 if (without_params
!= NULL
)
2983 make_cleanup (xfree
, without_params
);
2984 name
= without_params
;
2989 /* Index version 4 did not support case insensitive searches. But the
2990 indices for case insensitive languages are built in lowercase, therefore
2991 simulate our NAME being searched is also lowercased. */
2992 hash
= mapped_index_string_hash ((index
->version
== 4
2993 && case_sensitivity
== case_sensitive_off
2994 ? 5 : index
->version
),
2997 slot
= hash
& (index
->symbol_table_slots
- 1);
2998 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2999 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3003 /* Convert a slot number to an offset into the table. */
3004 offset_type i
= 2 * slot
;
3006 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
3008 do_cleanups (back_to
);
3012 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
3013 if (!cmp (name
, str
))
3015 *vec_out
= (offset_type
*) (index
->constant_pool
3016 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
3017 do_cleanups (back_to
);
3021 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
3025 /* A helper function that reads the .gdb_index from SECTION and fills
3026 in MAP. FILENAME is the name of the file containing the section;
3027 it is used for error reporting. DEPRECATED_OK is nonzero if it is
3028 ok to use deprecated sections.
3030 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3031 out parameters that are filled in with information about the CU and
3032 TU lists in the section.
3034 Returns 1 if all went well, 0 otherwise. */
3037 read_index_from_section (struct objfile
*objfile
,
3038 const char *filename
,
3040 struct dwarf2_section_info
*section
,
3041 struct mapped_index
*map
,
3042 const gdb_byte
**cu_list
,
3043 offset_type
*cu_list_elements
,
3044 const gdb_byte
**types_list
,
3045 offset_type
*types_list_elements
)
3047 const gdb_byte
*addr
;
3048 offset_type version
;
3049 offset_type
*metadata
;
3052 if (dwarf2_section_empty_p (section
))
3055 /* Older elfutils strip versions could keep the section in the main
3056 executable while splitting it for the separate debug info file. */
3057 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
3060 dwarf2_read_section (objfile
, section
);
3062 addr
= section
->buffer
;
3063 /* Version check. */
3064 version
= MAYBE_SWAP (*(offset_type
*) addr
);
3065 /* Versions earlier than 3 emitted every copy of a psymbol. This
3066 causes the index to behave very poorly for certain requests. Version 3
3067 contained incomplete addrmap. So, it seems better to just ignore such
3071 static int warning_printed
= 0;
3072 if (!warning_printed
)
3074 warning (_("Skipping obsolete .gdb_index section in %s."),
3076 warning_printed
= 1;
3080 /* Index version 4 uses a different hash function than index version
3083 Versions earlier than 6 did not emit psymbols for inlined
3084 functions. Using these files will cause GDB not to be able to
3085 set breakpoints on inlined functions by name, so we ignore these
3086 indices unless the user has done
3087 "set use-deprecated-index-sections on". */
3088 if (version
< 6 && !deprecated_ok
)
3090 static int warning_printed
= 0;
3091 if (!warning_printed
)
3094 Skipping deprecated .gdb_index section in %s.\n\
3095 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3096 to use the section anyway."),
3098 warning_printed
= 1;
3102 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3103 of the TU (for symbols coming from TUs),
3104 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3105 Plus gold-generated indices can have duplicate entries for global symbols,
3106 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3107 These are just performance bugs, and we can't distinguish gdb-generated
3108 indices from gold-generated ones, so issue no warning here. */
3110 /* Indexes with higher version than the one supported by GDB may be no
3111 longer backward compatible. */
3115 map
->version
= version
;
3116 map
->total_size
= section
->size
;
3118 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3121 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3122 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3126 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3127 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3128 - MAYBE_SWAP (metadata
[i
]))
3132 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3133 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
3134 - MAYBE_SWAP (metadata
[i
]));
3137 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
3138 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
3139 - MAYBE_SWAP (metadata
[i
]))
3140 / (2 * sizeof (offset_type
)));
3143 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3149 /* Read the index file. If everything went ok, initialize the "quick"
3150 elements of all the CUs and return 1. Otherwise, return 0. */
3153 dwarf2_read_index (struct objfile
*objfile
)
3155 struct mapped_index local_map
, *map
;
3156 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3157 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3158 struct dwz_file
*dwz
;
3160 if (!read_index_from_section (objfile
, objfile_name (objfile
),
3161 use_deprecated_index_sections
,
3162 &dwarf2_per_objfile
->gdb_index
, &local_map
,
3163 &cu_list
, &cu_list_elements
,
3164 &types_list
, &types_list_elements
))
3167 /* Don't use the index if it's empty. */
3168 if (local_map
.symbol_table_slots
== 0)
3171 /* If there is a .dwz file, read it so we can get its CU list as
3173 dwz
= dwarf2_get_dwz_file ();
3176 struct mapped_index dwz_map
;
3177 const gdb_byte
*dwz_types_ignore
;
3178 offset_type dwz_types_elements_ignore
;
3180 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
3182 &dwz
->gdb_index
, &dwz_map
,
3183 &dwz_list
, &dwz_list_elements
,
3185 &dwz_types_elements_ignore
))
3187 warning (_("could not read '.gdb_index' section from %s; skipping"),
3188 bfd_get_filename (dwz
->dwz_bfd
));
3193 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
3196 if (types_list_elements
)
3198 struct dwarf2_section_info
*section
;
3200 /* We can only handle a single .debug_types when we have an
3202 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3205 section
= VEC_index (dwarf2_section_info_def
,
3206 dwarf2_per_objfile
->types
, 0);
3208 create_signatured_type_table_from_index (objfile
, section
, types_list
,
3209 types_list_elements
);
3212 create_addrmap_from_index (objfile
, &local_map
);
3214 map
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct mapped_index
));
3217 dwarf2_per_objfile
->index_table
= map
;
3218 dwarf2_per_objfile
->using_index
= 1;
3219 dwarf2_per_objfile
->quick_file_names_table
=
3220 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3225 /* A helper for the "quick" functions which sets the global
3226 dwarf2_per_objfile according to OBJFILE. */
3229 dw2_setup (struct objfile
*objfile
)
3231 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
3232 gdb_assert (dwarf2_per_objfile
);
3235 /* die_reader_func for dw2_get_file_names. */
3238 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3239 const gdb_byte
*info_ptr
,
3240 struct die_info
*comp_unit_die
,
3244 struct dwarf2_cu
*cu
= reader
->cu
;
3245 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3246 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3247 struct dwarf2_per_cu_data
*lh_cu
;
3248 struct line_header
*lh
;
3249 struct attribute
*attr
;
3251 const char *name
, *comp_dir
;
3253 struct quick_file_names
*qfn
;
3254 unsigned int line_offset
;
3256 gdb_assert (! this_cu
->is_debug_types
);
3258 /* Our callers never want to match partial units -- instead they
3259 will match the enclosing full CU. */
3260 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3262 this_cu
->v
.quick
->no_file_data
= 1;
3271 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3274 struct quick_file_names find_entry
;
3276 line_offset
= DW_UNSND (attr
);
3278 /* We may have already read in this line header (TU line header sharing).
3279 If we have we're done. */
3280 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3281 find_entry
.hash
.line_offset
.sect_off
= line_offset
;
3282 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3283 &find_entry
, INSERT
);
3286 lh_cu
->v
.quick
->file_names
= *slot
;
3290 lh
= dwarf_decode_line_header (line_offset
, cu
);
3294 lh_cu
->v
.quick
->no_file_data
= 1;
3298 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
3299 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3300 qfn
->hash
.line_offset
.sect_off
= line_offset
;
3301 gdb_assert (slot
!= NULL
);
3304 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
3306 qfn
->num_file_names
= lh
->num_file_names
;
3307 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
3308 lh
->num_file_names
* sizeof (char *));
3309 for (i
= 0; i
< lh
->num_file_names
; ++i
)
3310 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
3311 qfn
->real_names
= NULL
;
3313 free_line_header (lh
);
3315 lh_cu
->v
.quick
->file_names
= qfn
;
3318 /* A helper for the "quick" functions which attempts to read the line
3319 table for THIS_CU. */
3321 static struct quick_file_names
*
3322 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3324 /* This should never be called for TUs. */
3325 gdb_assert (! this_cu
->is_debug_types
);
3326 /* Nor type unit groups. */
3327 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3329 if (this_cu
->v
.quick
->file_names
!= NULL
)
3330 return this_cu
->v
.quick
->file_names
;
3331 /* If we know there is no line data, no point in looking again. */
3332 if (this_cu
->v
.quick
->no_file_data
)
3335 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3337 if (this_cu
->v
.quick
->no_file_data
)
3339 return this_cu
->v
.quick
->file_names
;
3342 /* A helper for the "quick" functions which computes and caches the
3343 real path for a given file name from the line table. */
3346 dw2_get_real_path (struct objfile
*objfile
,
3347 struct quick_file_names
*qfn
, int index
)
3349 if (qfn
->real_names
== NULL
)
3350 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3351 qfn
->num_file_names
, const char *);
3353 if (qfn
->real_names
[index
] == NULL
)
3354 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
3356 return qfn
->real_names
[index
];
3359 static struct symtab
*
3360 dw2_find_last_source_symtab (struct objfile
*objfile
)
3362 struct compunit_symtab
*cust
;
3365 dw2_setup (objfile
);
3366 index
= dwarf2_per_objfile
->n_comp_units
- 1;
3367 cust
= dw2_instantiate_symtab (dw2_get_cutu (index
));
3370 return compunit_primary_filetab (cust
);
3373 /* Traversal function for dw2_forget_cached_source_info. */
3376 dw2_free_cached_file_names (void **slot
, void *info
)
3378 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3380 if (file_data
->real_names
)
3384 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3386 xfree ((void*) file_data
->real_names
[i
]);
3387 file_data
->real_names
[i
] = NULL
;
3395 dw2_forget_cached_source_info (struct objfile
*objfile
)
3397 dw2_setup (objfile
);
3399 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3400 dw2_free_cached_file_names
, NULL
);
3403 /* Helper function for dw2_map_symtabs_matching_filename that expands
3404 the symtabs and calls the iterator. */
3407 dw2_map_expand_apply (struct objfile
*objfile
,
3408 struct dwarf2_per_cu_data
*per_cu
,
3409 const char *name
, const char *real_path
,
3410 int (*callback
) (struct symtab
*, void *),
3413 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3415 /* Don't visit already-expanded CUs. */
3416 if (per_cu
->v
.quick
->compunit_symtab
)
3419 /* This may expand more than one symtab, and we want to iterate over
3421 dw2_instantiate_symtab (per_cu
);
3423 return iterate_over_some_symtabs (name
, real_path
, callback
, data
,
3424 objfile
->compunit_symtabs
, last_made
);
3427 /* Implementation of the map_symtabs_matching_filename method. */
3430 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
3431 const char *real_path
,
3432 int (*callback
) (struct symtab
*, void *),
3436 const char *name_basename
= lbasename (name
);
3438 dw2_setup (objfile
);
3440 /* The rule is CUs specify all the files, including those used by
3441 any TU, so there's no need to scan TUs here. */
3443 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3446 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3447 struct quick_file_names
*file_data
;
3449 /* We only need to look at symtabs not already expanded. */
3450 if (per_cu
->v
.quick
->compunit_symtab
)
3453 file_data
= dw2_get_file_names (per_cu
);
3454 if (file_data
== NULL
)
3457 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3459 const char *this_name
= file_data
->file_names
[j
];
3460 const char *this_real_name
;
3462 if (compare_filenames_for_search (this_name
, name
))
3464 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3470 /* Before we invoke realpath, which can get expensive when many
3471 files are involved, do a quick comparison of the basenames. */
3472 if (! basenames_may_differ
3473 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3476 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3477 if (compare_filenames_for_search (this_real_name
, name
))
3479 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3485 if (real_path
!= NULL
)
3487 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3488 gdb_assert (IS_ABSOLUTE_PATH (name
));
3489 if (this_real_name
!= NULL
3490 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3492 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3504 /* Struct used to manage iterating over all CUs looking for a symbol. */
3506 struct dw2_symtab_iterator
3508 /* The internalized form of .gdb_index. */
3509 struct mapped_index
*index
;
3510 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3511 int want_specific_block
;
3512 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3513 Unused if !WANT_SPECIFIC_BLOCK. */
3515 /* The kind of symbol we're looking for. */
3517 /* The list of CUs from the index entry of the symbol,
3518 or NULL if not found. */
3520 /* The next element in VEC to look at. */
3522 /* The number of elements in VEC, or zero if there is no match. */
3524 /* Have we seen a global version of the symbol?
3525 If so we can ignore all further global instances.
3526 This is to work around gold/15646, inefficient gold-generated
3531 /* Initialize the index symtab iterator ITER.
3532 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3533 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3536 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3537 struct mapped_index
*index
,
3538 int want_specific_block
,
3543 iter
->index
= index
;
3544 iter
->want_specific_block
= want_specific_block
;
3545 iter
->block_index
= block_index
;
3546 iter
->domain
= domain
;
3548 iter
->global_seen
= 0;
3550 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3551 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3559 /* Return the next matching CU or NULL if there are no more. */
3561 static struct dwarf2_per_cu_data
*
3562 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3564 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3566 offset_type cu_index_and_attrs
=
3567 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3568 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3569 struct dwarf2_per_cu_data
*per_cu
;
3570 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3571 /* This value is only valid for index versions >= 7. */
3572 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3573 gdb_index_symbol_kind symbol_kind
=
3574 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3575 /* Only check the symbol attributes if they're present.
3576 Indices prior to version 7 don't record them,
3577 and indices >= 7 may elide them for certain symbols
3578 (gold does this). */
3580 (iter
->index
->version
>= 7
3581 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3583 /* Don't crash on bad data. */
3584 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3585 + dwarf2_per_objfile
->n_type_units
))
3587 complaint (&symfile_complaints
,
3588 _(".gdb_index entry has bad CU index"
3590 objfile_name (dwarf2_per_objfile
->objfile
));
3594 per_cu
= dw2_get_cutu (cu_index
);
3596 /* Skip if already read in. */
3597 if (per_cu
->v
.quick
->compunit_symtab
)
3600 /* Check static vs global. */
3603 if (iter
->want_specific_block
3604 && want_static
!= is_static
)
3606 /* Work around gold/15646. */
3607 if (!is_static
&& iter
->global_seen
)
3610 iter
->global_seen
= 1;
3613 /* Only check the symbol's kind if it has one. */
3616 switch (iter
->domain
)
3619 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3620 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3621 /* Some types are also in VAR_DOMAIN. */
3622 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3626 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3630 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3645 static struct compunit_symtab
*
3646 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3647 const char *name
, domain_enum domain
)
3649 struct compunit_symtab
*stab_best
= NULL
;
3650 struct mapped_index
*index
;
3652 dw2_setup (objfile
);
3654 index
= dwarf2_per_objfile
->index_table
;
3656 /* index is NULL if OBJF_READNOW. */
3659 struct dw2_symtab_iterator iter
;
3660 struct dwarf2_per_cu_data
*per_cu
;
3662 dw2_symtab_iter_init (&iter
, index
, 1, block_index
, domain
, name
);
3664 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3666 struct symbol
*sym
= NULL
;
3667 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
);
3668 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3669 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3671 /* Some caution must be observed with overloaded functions
3672 and methods, since the index will not contain any overload
3673 information (but NAME might contain it). */
3674 sym
= block_lookup_symbol (block
, name
, domain
);
3676 if (sym
&& strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
3678 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
3684 /* Keep looking through other CUs. */
3692 dw2_print_stats (struct objfile
*objfile
)
3694 int i
, total
, count
;
3696 dw2_setup (objfile
);
3697 total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
3699 for (i
= 0; i
< total
; ++i
)
3701 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3703 if (!per_cu
->v
.quick
->compunit_symtab
)
3706 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3707 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3710 /* This dumps minimal information about the index.
3711 It is called via "mt print objfiles".
3712 One use is to verify .gdb_index has been loaded by the
3713 gdb.dwarf2/gdb-index.exp testcase. */
3716 dw2_dump (struct objfile
*objfile
)
3718 dw2_setup (objfile
);
3719 gdb_assert (dwarf2_per_objfile
->using_index
);
3720 printf_filtered (".gdb_index:");
3721 if (dwarf2_per_objfile
->index_table
!= NULL
)
3723 printf_filtered (" version %d\n",
3724 dwarf2_per_objfile
->index_table
->version
);
3727 printf_filtered (" faked for \"readnow\"\n");
3728 printf_filtered ("\n");
3732 dw2_relocate (struct objfile
*objfile
,
3733 const struct section_offsets
*new_offsets
,
3734 const struct section_offsets
*delta
)
3736 /* There's nothing to relocate here. */
3740 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3741 const char *func_name
)
3743 struct mapped_index
*index
;
3745 dw2_setup (objfile
);
3747 index
= dwarf2_per_objfile
->index_table
;
3749 /* index is NULL if OBJF_READNOW. */
3752 struct dw2_symtab_iterator iter
;
3753 struct dwarf2_per_cu_data
*per_cu
;
3755 /* Note: It doesn't matter what we pass for block_index here. */
3756 dw2_symtab_iter_init (&iter
, index
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
3759 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3760 dw2_instantiate_symtab (per_cu
);
3765 dw2_expand_all_symtabs (struct objfile
*objfile
)
3769 dw2_setup (objfile
);
3771 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3772 + dwarf2_per_objfile
->n_type_units
); ++i
)
3774 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3776 dw2_instantiate_symtab (per_cu
);
3781 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3782 const char *fullname
)
3786 dw2_setup (objfile
);
3788 /* We don't need to consider type units here.
3789 This is only called for examining code, e.g. expand_line_sal.
3790 There can be an order of magnitude (or more) more type units
3791 than comp units, and we avoid them if we can. */
3793 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3796 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3797 struct quick_file_names
*file_data
;
3799 /* We only need to look at symtabs not already expanded. */
3800 if (per_cu
->v
.quick
->compunit_symtab
)
3803 file_data
= dw2_get_file_names (per_cu
);
3804 if (file_data
== NULL
)
3807 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3809 const char *this_fullname
= file_data
->file_names
[j
];
3811 if (filename_cmp (this_fullname
, fullname
) == 0)
3813 dw2_instantiate_symtab (per_cu
);
3821 dw2_map_matching_symbols (struct objfile
*objfile
,
3822 const char * name
, domain_enum domain
,
3824 int (*callback
) (struct block
*,
3825 struct symbol
*, void *),
3826 void *data
, symbol_compare_ftype
*match
,
3827 symbol_compare_ftype
*ordered_compare
)
3829 /* Currently unimplemented; used for Ada. The function can be called if the
3830 current language is Ada for a non-Ada objfile using GNU index. As Ada
3831 does not look for non-Ada symbols this function should just return. */
3835 dw2_expand_symtabs_matching
3836 (struct objfile
*objfile
,
3837 expand_symtabs_file_matcher_ftype
*file_matcher
,
3838 expand_symtabs_symbol_matcher_ftype
*symbol_matcher
,
3839 expand_symtabs_exp_notify_ftype
*expansion_notify
,
3840 enum search_domain kind
,
3845 struct mapped_index
*index
;
3847 dw2_setup (objfile
);
3849 /* index_table is NULL if OBJF_READNOW. */
3850 if (!dwarf2_per_objfile
->index_table
)
3852 index
= dwarf2_per_objfile
->index_table
;
3854 if (file_matcher
!= NULL
)
3856 struct cleanup
*cleanup
;
3857 htab_t visited_found
, visited_not_found
;
3859 visited_found
= htab_create_alloc (10,
3860 htab_hash_pointer
, htab_eq_pointer
,
3861 NULL
, xcalloc
, xfree
);
3862 cleanup
= make_cleanup_htab_delete (visited_found
);
3863 visited_not_found
= htab_create_alloc (10,
3864 htab_hash_pointer
, htab_eq_pointer
,
3865 NULL
, xcalloc
, xfree
);
3866 make_cleanup_htab_delete (visited_not_found
);
3868 /* The rule is CUs specify all the files, including those used by
3869 any TU, so there's no need to scan TUs here. */
3871 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3874 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3875 struct quick_file_names
*file_data
;
3878 per_cu
->v
.quick
->mark
= 0;
3880 /* We only need to look at symtabs not already expanded. */
3881 if (per_cu
->v
.quick
->compunit_symtab
)
3884 file_data
= dw2_get_file_names (per_cu
);
3885 if (file_data
== NULL
)
3888 if (htab_find (visited_not_found
, file_data
) != NULL
)
3890 else if (htab_find (visited_found
, file_data
) != NULL
)
3892 per_cu
->v
.quick
->mark
= 1;
3896 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3898 const char *this_real_name
;
3900 if (file_matcher (file_data
->file_names
[j
], data
, 0))
3902 per_cu
->v
.quick
->mark
= 1;
3906 /* Before we invoke realpath, which can get expensive when many
3907 files are involved, do a quick comparison of the basenames. */
3908 if (!basenames_may_differ
3909 && !file_matcher (lbasename (file_data
->file_names
[j
]),
3913 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3914 if (file_matcher (this_real_name
, data
, 0))
3916 per_cu
->v
.quick
->mark
= 1;
3921 slot
= htab_find_slot (per_cu
->v
.quick
->mark
3923 : visited_not_found
,
3928 do_cleanups (cleanup
);
3931 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
3933 offset_type idx
= 2 * iter
;
3935 offset_type
*vec
, vec_len
, vec_idx
;
3936 int global_seen
= 0;
3938 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
3941 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
3943 if (! (*symbol_matcher
) (name
, data
))
3946 /* The name was matched, now expand corresponding CUs that were
3948 vec
= (offset_type
*) (index
->constant_pool
3949 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
3950 vec_len
= MAYBE_SWAP (vec
[0]);
3951 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
3953 struct dwarf2_per_cu_data
*per_cu
;
3954 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
3955 /* This value is only valid for index versions >= 7. */
3956 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3957 gdb_index_symbol_kind symbol_kind
=
3958 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3959 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3960 /* Only check the symbol attributes if they're present.
3961 Indices prior to version 7 don't record them,
3962 and indices >= 7 may elide them for certain symbols
3963 (gold does this). */
3965 (index
->version
>= 7
3966 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3968 /* Work around gold/15646. */
3971 if (!is_static
&& global_seen
)
3977 /* Only check the symbol's kind if it has one. */
3982 case VARIABLES_DOMAIN
:
3983 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
3986 case FUNCTIONS_DOMAIN
:
3987 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
3991 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3999 /* Don't crash on bad data. */
4000 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
4001 + dwarf2_per_objfile
->n_type_units
))
4003 complaint (&symfile_complaints
,
4004 _(".gdb_index entry has bad CU index"
4005 " [in module %s]"), objfile_name (objfile
));
4009 per_cu
= dw2_get_cutu (cu_index
);
4010 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4012 int symtab_was_null
=
4013 (per_cu
->v
.quick
->compunit_symtab
== NULL
);
4015 dw2_instantiate_symtab (per_cu
);
4017 if (expansion_notify
!= NULL
4019 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
4021 expansion_notify (per_cu
->v
.quick
->compunit_symtab
,
4029 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4032 static struct compunit_symtab
*
4033 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4038 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4039 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4042 if (cust
->includes
== NULL
)
4045 for (i
= 0; cust
->includes
[i
]; ++i
)
4047 struct compunit_symtab
*s
= cust
->includes
[i
];
4049 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4057 static struct compunit_symtab
*
4058 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
4059 struct bound_minimal_symbol msymbol
,
4061 struct obj_section
*section
,
4064 struct dwarf2_per_cu_data
*data
;
4065 struct compunit_symtab
*result
;
4067 dw2_setup (objfile
);
4069 if (!objfile
->psymtabs_addrmap
)
4072 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
4076 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
4077 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4078 paddress (get_objfile_arch (objfile
), pc
));
4081 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
),
4083 gdb_assert (result
!= NULL
);
4088 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4089 void *data
, int need_fullname
)
4092 struct cleanup
*cleanup
;
4093 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
4094 NULL
, xcalloc
, xfree
);
4096 cleanup
= make_cleanup_htab_delete (visited
);
4097 dw2_setup (objfile
);
4099 /* The rule is CUs specify all the files, including those used by
4100 any TU, so there's no need to scan TUs here.
4101 We can ignore file names coming from already-expanded CUs. */
4103 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4105 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4107 if (per_cu
->v
.quick
->compunit_symtab
)
4109 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
4112 *slot
= per_cu
->v
.quick
->file_names
;
4116 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4119 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4120 struct quick_file_names
*file_data
;
4123 /* We only need to look at symtabs not already expanded. */
4124 if (per_cu
->v
.quick
->compunit_symtab
)
4127 file_data
= dw2_get_file_names (per_cu
);
4128 if (file_data
== NULL
)
4131 slot
= htab_find_slot (visited
, file_data
, INSERT
);
4134 /* Already visited. */
4139 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4141 const char *this_real_name
;
4144 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
4146 this_real_name
= NULL
;
4147 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
4151 do_cleanups (cleanup
);
4155 dw2_has_symbols (struct objfile
*objfile
)
4160 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4163 dw2_find_last_source_symtab
,
4164 dw2_forget_cached_source_info
,
4165 dw2_map_symtabs_matching_filename
,
4170 dw2_expand_symtabs_for_function
,
4171 dw2_expand_all_symtabs
,
4172 dw2_expand_symtabs_with_fullname
,
4173 dw2_map_matching_symbols
,
4174 dw2_expand_symtabs_matching
,
4175 dw2_find_pc_sect_compunit_symtab
,
4176 dw2_map_symbol_filenames
4179 /* Initialize for reading DWARF for this objfile. Return 0 if this
4180 file will use psymtabs, or 1 if using the GNU index. */
4183 dwarf2_initialize_objfile (struct objfile
*objfile
)
4185 /* If we're about to read full symbols, don't bother with the
4186 indices. In this case we also don't care if some other debug
4187 format is making psymtabs, because they are all about to be
4189 if ((objfile
->flags
& OBJF_READNOW
))
4193 dwarf2_per_objfile
->using_index
= 1;
4194 create_all_comp_units (objfile
);
4195 create_all_type_units (objfile
);
4196 dwarf2_per_objfile
->quick_file_names_table
=
4197 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
4199 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
4200 + dwarf2_per_objfile
->n_type_units
); ++i
)
4202 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4204 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4205 struct dwarf2_per_cu_quick_data
);
4208 /* Return 1 so that gdb sees the "quick" functions. However,
4209 these functions will be no-ops because we will have expanded
4214 if (dwarf2_read_index (objfile
))
4222 /* Build a partial symbol table. */
4225 dwarf2_build_psymtabs (struct objfile
*objfile
)
4228 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
4230 init_psymbol_list (objfile
, 1024);
4235 /* This isn't really ideal: all the data we allocate on the
4236 objfile's obstack is still uselessly kept around. However,
4237 freeing it seems unsafe. */
4238 struct cleanup
*cleanups
= make_cleanup_discard_psymtabs (objfile
);
4240 dwarf2_build_psymtabs_hard (objfile
);
4241 discard_cleanups (cleanups
);
4243 CATCH (except
, RETURN_MASK_ERROR
)
4245 exception_print (gdb_stderr
, except
);
4250 /* Return the total length of the CU described by HEADER. */
4253 get_cu_length (const struct comp_unit_head
*header
)
4255 return header
->initial_length_size
+ header
->length
;
4258 /* Return TRUE if OFFSET is within CU_HEADER. */
4261 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
4263 sect_offset bottom
= { cu_header
->offset
.sect_off
};
4264 sect_offset top
= { cu_header
->offset
.sect_off
+ get_cu_length (cu_header
) };
4266 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
4269 /* Find the base address of the compilation unit for range lists and
4270 location lists. It will normally be specified by DW_AT_low_pc.
4271 In DWARF-3 draft 4, the base address could be overridden by
4272 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4273 compilation units with discontinuous ranges. */
4276 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
4278 struct attribute
*attr
;
4281 cu
->base_address
= 0;
4283 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
4286 cu
->base_address
= attr_value_as_address (attr
);
4291 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4294 cu
->base_address
= attr_value_as_address (attr
);
4300 /* Read in the comp unit header information from the debug_info at info_ptr.
4301 NOTE: This leaves members offset, first_die_offset to be filled in
4304 static const gdb_byte
*
4305 read_comp_unit_head (struct comp_unit_head
*cu_header
,
4306 const gdb_byte
*info_ptr
, bfd
*abfd
)
4309 unsigned int bytes_read
;
4311 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
4312 cu_header
->initial_length_size
= bytes_read
;
4313 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
4314 info_ptr
+= bytes_read
;
4315 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
4317 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
4319 info_ptr
+= bytes_read
;
4320 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
4322 signed_addr
= bfd_get_sign_extend_vma (abfd
);
4323 if (signed_addr
< 0)
4324 internal_error (__FILE__
, __LINE__
,
4325 _("read_comp_unit_head: dwarf from non elf file"));
4326 cu_header
->signed_addr_p
= signed_addr
;
4331 /* Helper function that returns the proper abbrev section for
4334 static struct dwarf2_section_info
*
4335 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
4337 struct dwarf2_section_info
*abbrev
;
4339 if (this_cu
->is_dwz
)
4340 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
4342 abbrev
= &dwarf2_per_objfile
->abbrev
;
4347 /* Subroutine of read_and_check_comp_unit_head and
4348 read_and_check_type_unit_head to simplify them.
4349 Perform various error checking on the header. */
4352 error_check_comp_unit_head (struct comp_unit_head
*header
,
4353 struct dwarf2_section_info
*section
,
4354 struct dwarf2_section_info
*abbrev_section
)
4356 bfd
*abfd
= get_section_bfd_owner (section
);
4357 const char *filename
= get_section_file_name (section
);
4359 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
4360 error (_("Dwarf Error: wrong version in compilation unit header "
4361 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
4364 if (header
->abbrev_offset
.sect_off
4365 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
4366 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4367 "(offset 0x%lx + 6) [in module %s]"),
4368 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
4371 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4372 avoid potential 32-bit overflow. */
4373 if (((unsigned long) header
->offset
.sect_off
+ get_cu_length (header
))
4375 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4376 "(offset 0x%lx + 0) [in module %s]"),
4377 (long) header
->length
, (long) header
->offset
.sect_off
,
4381 /* Read in a CU/TU header and perform some basic error checking.
4382 The contents of the header are stored in HEADER.
4383 The result is a pointer to the start of the first DIE. */
4385 static const gdb_byte
*
4386 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
4387 struct dwarf2_section_info
*section
,
4388 struct dwarf2_section_info
*abbrev_section
,
4389 const gdb_byte
*info_ptr
,
4390 int is_debug_types_section
)
4392 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4393 bfd
*abfd
= get_section_bfd_owner (section
);
4395 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4397 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4399 /* If we're reading a type unit, skip over the signature and
4400 type_offset fields. */
4401 if (is_debug_types_section
)
4402 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
4404 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4406 error_check_comp_unit_head (header
, section
, abbrev_section
);
4411 /* Read in the types comp unit header information from .debug_types entry at
4412 types_ptr. The result is a pointer to one past the end of the header. */
4414 static const gdb_byte
*
4415 read_and_check_type_unit_head (struct comp_unit_head
*header
,
4416 struct dwarf2_section_info
*section
,
4417 struct dwarf2_section_info
*abbrev_section
,
4418 const gdb_byte
*info_ptr
,
4419 ULONGEST
*signature
,
4420 cu_offset
*type_offset_in_tu
)
4422 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4423 bfd
*abfd
= get_section_bfd_owner (section
);
4425 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4427 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4429 /* If we're reading a type unit, skip over the signature and
4430 type_offset fields. */
4431 if (signature
!= NULL
)
4432 *signature
= read_8_bytes (abfd
, info_ptr
);
4434 if (type_offset_in_tu
!= NULL
)
4435 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
4436 header
->offset_size
);
4437 info_ptr
+= header
->offset_size
;
4439 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4441 error_check_comp_unit_head (header
, section
, abbrev_section
);
4446 /* Fetch the abbreviation table offset from a comp or type unit header. */
4449 read_abbrev_offset (struct dwarf2_section_info
*section
,
4452 bfd
*abfd
= get_section_bfd_owner (section
);
4453 const gdb_byte
*info_ptr
;
4454 unsigned int length
, initial_length_size
, offset_size
;
4455 sect_offset abbrev_offset
;
4457 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
4458 info_ptr
= section
->buffer
+ offset
.sect_off
;
4459 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
4460 offset_size
= initial_length_size
== 4 ? 4 : 8;
4461 info_ptr
+= initial_length_size
+ 2 /*version*/;
4462 abbrev_offset
.sect_off
= read_offset_1 (abfd
, info_ptr
, offset_size
);
4463 return abbrev_offset
;
4466 /* Allocate a new partial symtab for file named NAME and mark this new
4467 partial symtab as being an include of PST. */
4470 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
4471 struct objfile
*objfile
)
4473 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
4475 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
4477 /* It shares objfile->objfile_obstack. */
4478 subpst
->dirname
= pst
->dirname
;
4481 subpst
->section_offsets
= pst
->section_offsets
;
4482 subpst
->textlow
= 0;
4483 subpst
->texthigh
= 0;
4485 subpst
->dependencies
= (struct partial_symtab
**)
4486 obstack_alloc (&objfile
->objfile_obstack
,
4487 sizeof (struct partial_symtab
*));
4488 subpst
->dependencies
[0] = pst
;
4489 subpst
->number_of_dependencies
= 1;
4491 subpst
->globals_offset
= 0;
4492 subpst
->n_global_syms
= 0;
4493 subpst
->statics_offset
= 0;
4494 subpst
->n_static_syms
= 0;
4495 subpst
->compunit_symtab
= NULL
;
4496 subpst
->read_symtab
= pst
->read_symtab
;
4499 /* No private part is necessary for include psymtabs. This property
4500 can be used to differentiate between such include psymtabs and
4501 the regular ones. */
4502 subpst
->read_symtab_private
= NULL
;
4505 /* Read the Line Number Program data and extract the list of files
4506 included by the source file represented by PST. Build an include
4507 partial symtab for each of these included files. */
4510 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
4511 struct die_info
*die
,
4512 struct partial_symtab
*pst
)
4514 struct line_header
*lh
= NULL
;
4515 struct attribute
*attr
;
4517 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
4519 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
4521 return; /* No linetable, so no includes. */
4523 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4524 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, pst
->textlow
, 1);
4526 free_line_header (lh
);
4530 hash_signatured_type (const void *item
)
4532 const struct signatured_type
*sig_type
= item
;
4534 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4535 return sig_type
->signature
;
4539 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
4541 const struct signatured_type
*lhs
= item_lhs
;
4542 const struct signatured_type
*rhs
= item_rhs
;
4544 return lhs
->signature
== rhs
->signature
;
4547 /* Allocate a hash table for signatured types. */
4550 allocate_signatured_type_table (struct objfile
*objfile
)
4552 return htab_create_alloc_ex (41,
4553 hash_signatured_type
,
4556 &objfile
->objfile_obstack
,
4557 hashtab_obstack_allocate
,
4558 dummy_obstack_deallocate
);
4561 /* A helper function to add a signatured type CU to a table. */
4564 add_signatured_type_cu_to_table (void **slot
, void *datum
)
4566 struct signatured_type
*sigt
= *slot
;
4567 struct signatured_type
***datap
= datum
;
4575 /* Create the hash table of all entries in the .debug_types
4576 (or .debug_types.dwo) section(s).
4577 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4578 otherwise it is NULL.
4580 The result is a pointer to the hash table or NULL if there are no types.
4582 Note: This function processes DWO files only, not DWP files. */
4585 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
4586 VEC (dwarf2_section_info_def
) *types
)
4588 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4589 htab_t types_htab
= NULL
;
4591 struct dwarf2_section_info
*section
;
4592 struct dwarf2_section_info
*abbrev_section
;
4594 if (VEC_empty (dwarf2_section_info_def
, types
))
4597 abbrev_section
= (dwo_file
!= NULL
4598 ? &dwo_file
->sections
.abbrev
4599 : &dwarf2_per_objfile
->abbrev
);
4601 if (dwarf2_read_debug
)
4602 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_types%s for %s:\n",
4603 dwo_file
? ".dwo" : "",
4604 get_section_file_name (abbrev_section
));
4607 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
4611 const gdb_byte
*info_ptr
, *end_ptr
;
4613 dwarf2_read_section (objfile
, section
);
4614 info_ptr
= section
->buffer
;
4616 if (info_ptr
== NULL
)
4619 /* We can't set abfd until now because the section may be empty or
4620 not present, in which case the bfd is unknown. */
4621 abfd
= get_section_bfd_owner (section
);
4623 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4624 because we don't need to read any dies: the signature is in the
4627 end_ptr
= info_ptr
+ section
->size
;
4628 while (info_ptr
< end_ptr
)
4631 cu_offset type_offset_in_tu
;
4633 struct signatured_type
*sig_type
;
4634 struct dwo_unit
*dwo_tu
;
4636 const gdb_byte
*ptr
= info_ptr
;
4637 struct comp_unit_head header
;
4638 unsigned int length
;
4640 offset
.sect_off
= ptr
- section
->buffer
;
4642 /* We need to read the type's signature in order to build the hash
4643 table, but we don't need anything else just yet. */
4645 ptr
= read_and_check_type_unit_head (&header
, section
,
4646 abbrev_section
, ptr
,
4647 &signature
, &type_offset_in_tu
);
4649 length
= get_cu_length (&header
);
4651 /* Skip dummy type units. */
4652 if (ptr
>= info_ptr
+ length
4653 || peek_abbrev_code (abfd
, ptr
) == 0)
4659 if (types_htab
== NULL
)
4662 types_htab
= allocate_dwo_unit_table (objfile
);
4664 types_htab
= allocate_signatured_type_table (objfile
);
4670 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4672 dwo_tu
->dwo_file
= dwo_file
;
4673 dwo_tu
->signature
= signature
;
4674 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
4675 dwo_tu
->section
= section
;
4676 dwo_tu
->offset
= offset
;
4677 dwo_tu
->length
= length
;
4681 /* N.B.: type_offset is not usable if this type uses a DWO file.
4682 The real type_offset is in the DWO file. */
4684 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4685 struct signatured_type
);
4686 sig_type
->signature
= signature
;
4687 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
4688 sig_type
->per_cu
.objfile
= objfile
;
4689 sig_type
->per_cu
.is_debug_types
= 1;
4690 sig_type
->per_cu
.section
= section
;
4691 sig_type
->per_cu
.offset
= offset
;
4692 sig_type
->per_cu
.length
= length
;
4695 slot
= htab_find_slot (types_htab
,
4696 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
4698 gdb_assert (slot
!= NULL
);
4701 sect_offset dup_offset
;
4705 const struct dwo_unit
*dup_tu
= *slot
;
4707 dup_offset
= dup_tu
->offset
;
4711 const struct signatured_type
*dup_tu
= *slot
;
4713 dup_offset
= dup_tu
->per_cu
.offset
;
4716 complaint (&symfile_complaints
,
4717 _("debug type entry at offset 0x%x is duplicate to"
4718 " the entry at offset 0x%x, signature %s"),
4719 offset
.sect_off
, dup_offset
.sect_off
,
4720 hex_string (signature
));
4722 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
4724 if (dwarf2_read_debug
> 1)
4725 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature %s\n",
4727 hex_string (signature
));
4736 /* Create the hash table of all entries in the .debug_types section,
4737 and initialize all_type_units.
4738 The result is zero if there is an error (e.g. missing .debug_types section),
4739 otherwise non-zero. */
4742 create_all_type_units (struct objfile
*objfile
)
4745 struct signatured_type
**iter
;
4747 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
4748 if (types_htab
== NULL
)
4750 dwarf2_per_objfile
->signatured_types
= NULL
;
4754 dwarf2_per_objfile
->signatured_types
= types_htab
;
4756 dwarf2_per_objfile
->n_type_units
4757 = dwarf2_per_objfile
->n_allocated_type_units
4758 = htab_elements (types_htab
);
4759 dwarf2_per_objfile
->all_type_units
4760 = xmalloc (dwarf2_per_objfile
->n_type_units
4761 * sizeof (struct signatured_type
*));
4762 iter
= &dwarf2_per_objfile
->all_type_units
[0];
4763 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
4764 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
4765 == dwarf2_per_objfile
->n_type_units
);
4770 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
4771 If SLOT is non-NULL, it is the entry to use in the hash table.
4772 Otherwise we find one. */
4774 static struct signatured_type
*
4775 add_type_unit (ULONGEST sig
, void **slot
)
4777 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4778 int n_type_units
= dwarf2_per_objfile
->n_type_units
;
4779 struct signatured_type
*sig_type
;
4781 gdb_assert (n_type_units
<= dwarf2_per_objfile
->n_allocated_type_units
);
4783 if (n_type_units
> dwarf2_per_objfile
->n_allocated_type_units
)
4785 if (dwarf2_per_objfile
->n_allocated_type_units
== 0)
4786 dwarf2_per_objfile
->n_allocated_type_units
= 1;
4787 dwarf2_per_objfile
->n_allocated_type_units
*= 2;
4788 dwarf2_per_objfile
->all_type_units
4789 = xrealloc (dwarf2_per_objfile
->all_type_units
,
4790 dwarf2_per_objfile
->n_allocated_type_units
4791 * sizeof (struct signatured_type
*));
4792 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
4794 dwarf2_per_objfile
->n_type_units
= n_type_units
;
4796 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4797 struct signatured_type
);
4798 dwarf2_per_objfile
->all_type_units
[n_type_units
- 1] = sig_type
;
4799 sig_type
->signature
= sig
;
4800 sig_type
->per_cu
.is_debug_types
= 1;
4801 if (dwarf2_per_objfile
->using_index
)
4803 sig_type
->per_cu
.v
.quick
=
4804 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4805 struct dwarf2_per_cu_quick_data
);
4810 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4813 gdb_assert (*slot
== NULL
);
4815 /* The rest of sig_type must be filled in by the caller. */
4819 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4820 Fill in SIG_ENTRY with DWO_ENTRY. */
4823 fill_in_sig_entry_from_dwo_entry (struct objfile
*objfile
,
4824 struct signatured_type
*sig_entry
,
4825 struct dwo_unit
*dwo_entry
)
4827 /* Make sure we're not clobbering something we don't expect to. */
4828 gdb_assert (! sig_entry
->per_cu
.queued
);
4829 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
4830 if (dwarf2_per_objfile
->using_index
)
4832 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
4833 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
4836 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
4837 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
4838 gdb_assert (sig_entry
->type_offset_in_section
.sect_off
== 0);
4839 gdb_assert (sig_entry
->type_unit_group
== NULL
);
4840 gdb_assert (sig_entry
->dwo_unit
== NULL
);
4842 sig_entry
->per_cu
.section
= dwo_entry
->section
;
4843 sig_entry
->per_cu
.offset
= dwo_entry
->offset
;
4844 sig_entry
->per_cu
.length
= dwo_entry
->length
;
4845 sig_entry
->per_cu
.reading_dwo_directly
= 1;
4846 sig_entry
->per_cu
.objfile
= objfile
;
4847 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
4848 sig_entry
->dwo_unit
= dwo_entry
;
4851 /* Subroutine of lookup_signatured_type.
4852 If we haven't read the TU yet, create the signatured_type data structure
4853 for a TU to be read in directly from a DWO file, bypassing the stub.
4854 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4855 using .gdb_index, then when reading a CU we want to stay in the DWO file
4856 containing that CU. Otherwise we could end up reading several other DWO
4857 files (due to comdat folding) to process the transitive closure of all the
4858 mentioned TUs, and that can be slow. The current DWO file will have every
4859 type signature that it needs.
4860 We only do this for .gdb_index because in the psymtab case we already have
4861 to read all the DWOs to build the type unit groups. */
4863 static struct signatured_type
*
4864 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4866 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4867 struct dwo_file
*dwo_file
;
4868 struct dwo_unit find_dwo_entry
, *dwo_entry
;
4869 struct signatured_type find_sig_entry
, *sig_entry
;
4872 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4874 /* If TU skeletons have been removed then we may not have read in any
4876 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4878 dwarf2_per_objfile
->signatured_types
4879 = allocate_signatured_type_table (objfile
);
4882 /* We only ever need to read in one copy of a signatured type.
4883 Use the global signatured_types array to do our own comdat-folding
4884 of types. If this is the first time we're reading this TU, and
4885 the TU has an entry in .gdb_index, replace the recorded data from
4886 .gdb_index with this TU. */
4888 find_sig_entry
.signature
= sig
;
4889 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4890 &find_sig_entry
, INSERT
);
4893 /* We can get here with the TU already read, *or* in the process of being
4894 read. Don't reassign the global entry to point to this DWO if that's
4895 the case. Also note that if the TU is already being read, it may not
4896 have come from a DWO, the program may be a mix of Fission-compiled
4897 code and non-Fission-compiled code. */
4899 /* Have we already tried to read this TU?
4900 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4901 needn't exist in the global table yet). */
4902 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
4905 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4906 dwo_unit of the TU itself. */
4907 dwo_file
= cu
->dwo_unit
->dwo_file
;
4909 /* Ok, this is the first time we're reading this TU. */
4910 if (dwo_file
->tus
== NULL
)
4912 find_dwo_entry
.signature
= sig
;
4913 dwo_entry
= htab_find (dwo_file
->tus
, &find_dwo_entry
);
4914 if (dwo_entry
== NULL
)
4917 /* If the global table doesn't have an entry for this TU, add one. */
4918 if (sig_entry
== NULL
)
4919 sig_entry
= add_type_unit (sig
, slot
);
4921 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4922 sig_entry
->per_cu
.tu_read
= 1;
4926 /* Subroutine of lookup_signatured_type.
4927 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4928 then try the DWP file. If the TU stub (skeleton) has been removed then
4929 it won't be in .gdb_index. */
4931 static struct signatured_type
*
4932 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4934 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4935 struct dwp_file
*dwp_file
= get_dwp_file ();
4936 struct dwo_unit
*dwo_entry
;
4937 struct signatured_type find_sig_entry
, *sig_entry
;
4940 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4941 gdb_assert (dwp_file
!= NULL
);
4943 /* If TU skeletons have been removed then we may not have read in any
4945 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4947 dwarf2_per_objfile
->signatured_types
4948 = allocate_signatured_type_table (objfile
);
4951 find_sig_entry
.signature
= sig
;
4952 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4953 &find_sig_entry
, INSERT
);
4956 /* Have we already tried to read this TU?
4957 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4958 needn't exist in the global table yet). */
4959 if (sig_entry
!= NULL
)
4962 if (dwp_file
->tus
== NULL
)
4964 dwo_entry
= lookup_dwo_unit_in_dwp (dwp_file
, NULL
,
4965 sig
, 1 /* is_debug_types */);
4966 if (dwo_entry
== NULL
)
4969 sig_entry
= add_type_unit (sig
, slot
);
4970 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4975 /* Lookup a signature based type for DW_FORM_ref_sig8.
4976 Returns NULL if signature SIG is not present in the table.
4977 It is up to the caller to complain about this. */
4979 static struct signatured_type
*
4980 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4983 && dwarf2_per_objfile
->using_index
)
4985 /* We're in a DWO/DWP file, and we're using .gdb_index.
4986 These cases require special processing. */
4987 if (get_dwp_file () == NULL
)
4988 return lookup_dwo_signatured_type (cu
, sig
);
4990 return lookup_dwp_signatured_type (cu
, sig
);
4994 struct signatured_type find_entry
, *entry
;
4996 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4998 find_entry
.signature
= sig
;
4999 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
5004 /* Low level DIE reading support. */
5006 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
5009 init_cu_die_reader (struct die_reader_specs
*reader
,
5010 struct dwarf2_cu
*cu
,
5011 struct dwarf2_section_info
*section
,
5012 struct dwo_file
*dwo_file
)
5014 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
5015 reader
->abfd
= get_section_bfd_owner (section
);
5017 reader
->dwo_file
= dwo_file
;
5018 reader
->die_section
= section
;
5019 reader
->buffer
= section
->buffer
;
5020 reader
->buffer_end
= section
->buffer
+ section
->size
;
5021 reader
->comp_dir
= NULL
;
5024 /* Subroutine of init_cutu_and_read_dies to simplify it.
5025 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
5026 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
5029 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
5030 from it to the DIE in the DWO. If NULL we are skipping the stub.
5031 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
5032 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
5033 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
5034 STUB_COMP_DIR may be non-NULL.
5035 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
5036 are filled in with the info of the DIE from the DWO file.
5037 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
5038 provided an abbrev table to use.
5039 The result is non-zero if a valid (non-dummy) DIE was found. */
5042 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
5043 struct dwo_unit
*dwo_unit
,
5044 int abbrev_table_provided
,
5045 struct die_info
*stub_comp_unit_die
,
5046 const char *stub_comp_dir
,
5047 struct die_reader_specs
*result_reader
,
5048 const gdb_byte
**result_info_ptr
,
5049 struct die_info
**result_comp_unit_die
,
5050 int *result_has_children
)
5052 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5053 struct dwarf2_cu
*cu
= this_cu
->cu
;
5054 struct dwarf2_section_info
*section
;
5056 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5057 ULONGEST signature
; /* Or dwo_id. */
5058 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
5059 int i
,num_extra_attrs
;
5060 struct dwarf2_section_info
*dwo_abbrev_section
;
5061 struct attribute
*attr
;
5062 struct die_info
*comp_unit_die
;
5064 /* At most one of these may be provided. */
5065 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
5067 /* These attributes aren't processed until later:
5068 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
5069 DW_AT_comp_dir is used now, to find the DWO file, but it is also
5070 referenced later. However, these attributes are found in the stub
5071 which we won't have later. In order to not impose this complication
5072 on the rest of the code, we read them here and copy them to the
5081 if (stub_comp_unit_die
!= NULL
)
5083 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5085 if (! this_cu
->is_debug_types
)
5086 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
5087 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
5088 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
5089 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
5090 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
5092 /* There should be a DW_AT_addr_base attribute here (if needed).
5093 We need the value before we can process DW_FORM_GNU_addr_index. */
5095 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
5097 cu
->addr_base
= DW_UNSND (attr
);
5099 /* There should be a DW_AT_ranges_base attribute here (if needed).
5100 We need the value before we can process DW_AT_ranges. */
5101 cu
->ranges_base
= 0;
5102 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
5104 cu
->ranges_base
= DW_UNSND (attr
);
5106 else if (stub_comp_dir
!= NULL
)
5108 /* Reconstruct the comp_dir attribute to simplify the code below. */
5109 comp_dir
= (struct attribute
*)
5110 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (*comp_dir
));
5111 comp_dir
->name
= DW_AT_comp_dir
;
5112 comp_dir
->form
= DW_FORM_string
;
5113 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
5114 DW_STRING (comp_dir
) = stub_comp_dir
;
5117 /* Set up for reading the DWO CU/TU. */
5118 cu
->dwo_unit
= dwo_unit
;
5119 section
= dwo_unit
->section
;
5120 dwarf2_read_section (objfile
, section
);
5121 abfd
= get_section_bfd_owner (section
);
5122 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
5123 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
5124 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
5126 if (this_cu
->is_debug_types
)
5128 ULONGEST header_signature
;
5129 cu_offset type_offset_in_tu
;
5130 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
5132 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5136 &type_offset_in_tu
);
5137 /* This is not an assert because it can be caused by bad debug info. */
5138 if (sig_type
->signature
!= header_signature
)
5140 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5141 " TU at offset 0x%x [in module %s]"),
5142 hex_string (sig_type
->signature
),
5143 hex_string (header_signature
),
5144 dwo_unit
->offset
.sect_off
,
5145 bfd_get_filename (abfd
));
5147 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5148 /* For DWOs coming from DWP files, we don't know the CU length
5149 nor the type's offset in the TU until now. */
5150 dwo_unit
->length
= get_cu_length (&cu
->header
);
5151 dwo_unit
->type_offset_in_tu
= type_offset_in_tu
;
5153 /* Establish the type offset that can be used to lookup the type.
5154 For DWO files, we don't know it until now. */
5155 sig_type
->type_offset_in_section
.sect_off
=
5156 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
5160 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5163 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5164 /* For DWOs coming from DWP files, we don't know the CU length
5166 dwo_unit
->length
= get_cu_length (&cu
->header
);
5169 /* Replace the CU's original abbrev table with the DWO's.
5170 Reminder: We can't read the abbrev table until we've read the header. */
5171 if (abbrev_table_provided
)
5173 /* Don't free the provided abbrev table, the caller of
5174 init_cutu_and_read_dies owns it. */
5175 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5176 /* Ensure the DWO abbrev table gets freed. */
5177 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5181 dwarf2_free_abbrev_table (cu
);
5182 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5183 /* Leave any existing abbrev table cleanup as is. */
5186 /* Read in the die, but leave space to copy over the attributes
5187 from the stub. This has the benefit of simplifying the rest of
5188 the code - all the work to maintain the illusion of a single
5189 DW_TAG_{compile,type}_unit DIE is done here. */
5190 num_extra_attrs
= ((stmt_list
!= NULL
)
5194 + (comp_dir
!= NULL
));
5195 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
5196 result_has_children
, num_extra_attrs
);
5198 /* Copy over the attributes from the stub to the DIE we just read in. */
5199 comp_unit_die
= *result_comp_unit_die
;
5200 i
= comp_unit_die
->num_attrs
;
5201 if (stmt_list
!= NULL
)
5202 comp_unit_die
->attrs
[i
++] = *stmt_list
;
5204 comp_unit_die
->attrs
[i
++] = *low_pc
;
5205 if (high_pc
!= NULL
)
5206 comp_unit_die
->attrs
[i
++] = *high_pc
;
5208 comp_unit_die
->attrs
[i
++] = *ranges
;
5209 if (comp_dir
!= NULL
)
5210 comp_unit_die
->attrs
[i
++] = *comp_dir
;
5211 comp_unit_die
->num_attrs
+= num_extra_attrs
;
5213 if (dwarf2_die_debug
)
5215 fprintf_unfiltered (gdb_stdlog
,
5216 "Read die from %s@0x%x of %s:\n",
5217 get_section_name (section
),
5218 (unsigned) (begin_info_ptr
- section
->buffer
),
5219 bfd_get_filename (abfd
));
5220 dump_die (comp_unit_die
, dwarf2_die_debug
);
5223 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5224 TUs by skipping the stub and going directly to the entry in the DWO file.
5225 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5226 to get it via circuitous means. Blech. */
5227 if (comp_dir
!= NULL
)
5228 result_reader
->comp_dir
= DW_STRING (comp_dir
);
5230 /* Skip dummy compilation units. */
5231 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
5232 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5235 *result_info_ptr
= info_ptr
;
5239 /* Subroutine of init_cutu_and_read_dies to simplify it.
5240 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5241 Returns NULL if the specified DWO unit cannot be found. */
5243 static struct dwo_unit
*
5244 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
5245 struct die_info
*comp_unit_die
)
5247 struct dwarf2_cu
*cu
= this_cu
->cu
;
5248 struct attribute
*attr
;
5250 struct dwo_unit
*dwo_unit
;
5251 const char *comp_dir
, *dwo_name
;
5253 gdb_assert (cu
!= NULL
);
5255 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5256 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5257 gdb_assert (attr
!= NULL
);
5258 dwo_name
= DW_STRING (attr
);
5260 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5262 comp_dir
= DW_STRING (attr
);
5264 if (this_cu
->is_debug_types
)
5266 struct signatured_type
*sig_type
;
5268 /* Since this_cu is the first member of struct signatured_type,
5269 we can go from a pointer to one to a pointer to the other. */
5270 sig_type
= (struct signatured_type
*) this_cu
;
5271 signature
= sig_type
->signature
;
5272 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
5276 struct attribute
*attr
;
5278 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
5280 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5282 dwo_name
, objfile_name (this_cu
->objfile
));
5283 signature
= DW_UNSND (attr
);
5284 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
5291 /* Subroutine of init_cutu_and_read_dies to simplify it.
5292 See it for a description of the parameters.
5293 Read a TU directly from a DWO file, bypassing the stub.
5295 Note: This function could be a little bit simpler if we shared cleanups
5296 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
5297 to do, so we keep this function self-contained. Or we could move this
5298 into our caller, but it's complex enough already. */
5301 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
5302 int use_existing_cu
, int keep
,
5303 die_reader_func_ftype
*die_reader_func
,
5306 struct dwarf2_cu
*cu
;
5307 struct signatured_type
*sig_type
;
5308 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5309 struct die_reader_specs reader
;
5310 const gdb_byte
*info_ptr
;
5311 struct die_info
*comp_unit_die
;
5314 /* Verify we can do the following downcast, and that we have the
5316 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
5317 sig_type
= (struct signatured_type
*) this_cu
;
5318 gdb_assert (sig_type
->dwo_unit
!= NULL
);
5320 cleanups
= make_cleanup (null_cleanup
, NULL
);
5322 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5324 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
5326 /* There's no need to do the rereading_dwo_cu handling that
5327 init_cutu_and_read_dies does since we don't read the stub. */
5331 /* If !use_existing_cu, this_cu->cu must be NULL. */
5332 gdb_assert (this_cu
->cu
== NULL
);
5333 cu
= xmalloc (sizeof (*cu
));
5334 init_one_comp_unit (cu
, this_cu
);
5335 /* If an error occurs while loading, release our storage. */
5336 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5339 /* A future optimization, if needed, would be to use an existing
5340 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
5341 could share abbrev tables. */
5343 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
5344 0 /* abbrev_table_provided */,
5345 NULL
/* stub_comp_unit_die */,
5346 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
5348 &comp_unit_die
, &has_children
) == 0)
5351 do_cleanups (cleanups
);
5355 /* All the "real" work is done here. */
5356 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5358 /* This duplicates the code in init_cutu_and_read_dies,
5359 but the alternative is making the latter more complex.
5360 This function is only for the special case of using DWO files directly:
5361 no point in overly complicating the general case just to handle this. */
5362 if (free_cu_cleanup
!= NULL
)
5366 /* We've successfully allocated this compilation unit. Let our
5367 caller clean it up when finished with it. */
5368 discard_cleanups (free_cu_cleanup
);
5370 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5371 So we have to manually free the abbrev table. */
5372 dwarf2_free_abbrev_table (cu
);
5374 /* Link this CU into read_in_chain. */
5375 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5376 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5379 do_cleanups (free_cu_cleanup
);
5382 do_cleanups (cleanups
);
5385 /* Initialize a CU (or TU) and read its DIEs.
5386 If the CU defers to a DWO file, read the DWO file as well.
5388 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5389 Otherwise the table specified in the comp unit header is read in and used.
5390 This is an optimization for when we already have the abbrev table.
5392 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5393 Otherwise, a new CU is allocated with xmalloc.
5395 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5396 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5398 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5399 linker) then DIE_READER_FUNC will not get called. */
5402 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
5403 struct abbrev_table
*abbrev_table
,
5404 int use_existing_cu
, int keep
,
5405 die_reader_func_ftype
*die_reader_func
,
5408 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5409 struct dwarf2_section_info
*section
= this_cu
->section
;
5410 bfd
*abfd
= get_section_bfd_owner (section
);
5411 struct dwarf2_cu
*cu
;
5412 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5413 struct die_reader_specs reader
;
5414 struct die_info
*comp_unit_die
;
5416 struct attribute
*attr
;
5417 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5418 struct signatured_type
*sig_type
= NULL
;
5419 struct dwarf2_section_info
*abbrev_section
;
5420 /* Non-zero if CU currently points to a DWO file and we need to
5421 reread it. When this happens we need to reread the skeleton die
5422 before we can reread the DWO file (this only applies to CUs, not TUs). */
5423 int rereading_dwo_cu
= 0;
5425 if (dwarf2_die_debug
)
5426 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5427 this_cu
->is_debug_types
? "type" : "comp",
5428 this_cu
->offset
.sect_off
);
5430 if (use_existing_cu
)
5433 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5434 file (instead of going through the stub), short-circuit all of this. */
5435 if (this_cu
->reading_dwo_directly
)
5437 /* Narrow down the scope of possibilities to have to understand. */
5438 gdb_assert (this_cu
->is_debug_types
);
5439 gdb_assert (abbrev_table
== NULL
);
5440 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
5441 die_reader_func
, data
);
5445 cleanups
= make_cleanup (null_cleanup
, NULL
);
5447 /* This is cheap if the section is already read in. */
5448 dwarf2_read_section (objfile
, section
);
5450 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5452 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
5454 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5457 /* If this CU is from a DWO file we need to start over, we need to
5458 refetch the attributes from the skeleton CU.
5459 This could be optimized by retrieving those attributes from when we
5460 were here the first time: the previous comp_unit_die was stored in
5461 comp_unit_obstack. But there's no data yet that we need this
5463 if (cu
->dwo_unit
!= NULL
)
5464 rereading_dwo_cu
= 1;
5468 /* If !use_existing_cu, this_cu->cu must be NULL. */
5469 gdb_assert (this_cu
->cu
== NULL
);
5470 cu
= xmalloc (sizeof (*cu
));
5471 init_one_comp_unit (cu
, this_cu
);
5472 /* If an error occurs while loading, release our storage. */
5473 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5476 /* Get the header. */
5477 if (cu
->header
.first_die_offset
.cu_off
!= 0 && ! rereading_dwo_cu
)
5479 /* We already have the header, there's no need to read it in again. */
5480 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
5484 if (this_cu
->is_debug_types
)
5487 cu_offset type_offset_in_tu
;
5489 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5490 abbrev_section
, info_ptr
,
5492 &type_offset_in_tu
);
5494 /* Since per_cu is the first member of struct signatured_type,
5495 we can go from a pointer to one to a pointer to the other. */
5496 sig_type
= (struct signatured_type
*) this_cu
;
5497 gdb_assert (sig_type
->signature
== signature
);
5498 gdb_assert (sig_type
->type_offset_in_tu
.cu_off
5499 == type_offset_in_tu
.cu_off
);
5500 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5502 /* LENGTH has not been set yet for type units if we're
5503 using .gdb_index. */
5504 this_cu
->length
= get_cu_length (&cu
->header
);
5506 /* Establish the type offset that can be used to lookup the type. */
5507 sig_type
->type_offset_in_section
.sect_off
=
5508 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
5512 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5516 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5517 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
5521 /* Skip dummy compilation units. */
5522 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5523 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5525 do_cleanups (cleanups
);
5529 /* If we don't have them yet, read the abbrevs for this compilation unit.
5530 And if we need to read them now, make sure they're freed when we're
5531 done. Note that it's important that if the CU had an abbrev table
5532 on entry we don't free it when we're done: Somewhere up the call stack
5533 it may be in use. */
5534 if (abbrev_table
!= NULL
)
5536 gdb_assert (cu
->abbrev_table
== NULL
);
5537 gdb_assert (cu
->header
.abbrev_offset
.sect_off
5538 == abbrev_table
->offset
.sect_off
);
5539 cu
->abbrev_table
= abbrev_table
;
5541 else if (cu
->abbrev_table
== NULL
)
5543 dwarf2_read_abbrevs (cu
, abbrev_section
);
5544 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5546 else if (rereading_dwo_cu
)
5548 dwarf2_free_abbrev_table (cu
);
5549 dwarf2_read_abbrevs (cu
, abbrev_section
);
5552 /* Read the top level CU/TU die. */
5553 init_cu_die_reader (&reader
, cu
, section
, NULL
);
5554 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5556 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5558 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5559 DWO CU, that this test will fail (the attribute will not be present). */
5560 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5563 struct dwo_unit
*dwo_unit
;
5564 struct die_info
*dwo_comp_unit_die
;
5568 complaint (&symfile_complaints
,
5569 _("compilation unit with DW_AT_GNU_dwo_name"
5570 " has children (offset 0x%x) [in module %s]"),
5571 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
5573 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
5574 if (dwo_unit
!= NULL
)
5576 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
5577 abbrev_table
!= NULL
,
5578 comp_unit_die
, NULL
,
5580 &dwo_comp_unit_die
, &has_children
) == 0)
5583 do_cleanups (cleanups
);
5586 comp_unit_die
= dwo_comp_unit_die
;
5590 /* Yikes, we couldn't find the rest of the DIE, we only have
5591 the stub. A complaint has already been logged. There's
5592 not much more we can do except pass on the stub DIE to
5593 die_reader_func. We don't want to throw an error on bad
5598 /* All of the above is setup for this call. Yikes. */
5599 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5601 /* Done, clean up. */
5602 if (free_cu_cleanup
!= NULL
)
5606 /* We've successfully allocated this compilation unit. Let our
5607 caller clean it up when finished with it. */
5608 discard_cleanups (free_cu_cleanup
);
5610 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5611 So we have to manually free the abbrev table. */
5612 dwarf2_free_abbrev_table (cu
);
5614 /* Link this CU into read_in_chain. */
5615 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5616 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5619 do_cleanups (free_cu_cleanup
);
5622 do_cleanups (cleanups
);
5625 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5626 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5627 to have already done the lookup to find the DWO file).
5629 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5630 THIS_CU->is_debug_types, but nothing else.
5632 We fill in THIS_CU->length.
5634 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5635 linker) then DIE_READER_FUNC will not get called.
5637 THIS_CU->cu is always freed when done.
5638 This is done in order to not leave THIS_CU->cu in a state where we have
5639 to care whether it refers to the "main" CU or the DWO CU. */
5642 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
5643 struct dwo_file
*dwo_file
,
5644 die_reader_func_ftype
*die_reader_func
,
5647 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5648 struct dwarf2_section_info
*section
= this_cu
->section
;
5649 bfd
*abfd
= get_section_bfd_owner (section
);
5650 struct dwarf2_section_info
*abbrev_section
;
5651 struct dwarf2_cu cu
;
5652 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5653 struct die_reader_specs reader
;
5654 struct cleanup
*cleanups
;
5655 struct die_info
*comp_unit_die
;
5658 if (dwarf2_die_debug
)
5659 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5660 this_cu
->is_debug_types
? "type" : "comp",
5661 this_cu
->offset
.sect_off
);
5663 gdb_assert (this_cu
->cu
== NULL
);
5665 abbrev_section
= (dwo_file
!= NULL
5666 ? &dwo_file
->sections
.abbrev
5667 : get_abbrev_section_for_cu (this_cu
));
5669 /* This is cheap if the section is already read in. */
5670 dwarf2_read_section (objfile
, section
);
5672 init_one_comp_unit (&cu
, this_cu
);
5674 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
5676 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5677 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
5678 abbrev_section
, info_ptr
,
5679 this_cu
->is_debug_types
);
5681 this_cu
->length
= get_cu_length (&cu
.header
);
5683 /* Skip dummy compilation units. */
5684 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5685 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5687 do_cleanups (cleanups
);
5691 dwarf2_read_abbrevs (&cu
, abbrev_section
);
5692 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
5694 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
5695 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5697 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5699 do_cleanups (cleanups
);
5702 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5703 does not lookup the specified DWO file.
5704 This cannot be used to read DWO files.
5706 THIS_CU->cu is always freed when done.
5707 This is done in order to not leave THIS_CU->cu in a state where we have
5708 to care whether it refers to the "main" CU or the DWO CU.
5709 We can revisit this if the data shows there's a performance issue. */
5712 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
5713 die_reader_func_ftype
*die_reader_func
,
5716 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
5719 /* Type Unit Groups.
5721 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5722 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5723 so that all types coming from the same compilation (.o file) are grouped
5724 together. A future step could be to put the types in the same symtab as
5725 the CU the types ultimately came from. */
5728 hash_type_unit_group (const void *item
)
5730 const struct type_unit_group
*tu_group
= item
;
5732 return hash_stmt_list_entry (&tu_group
->hash
);
5736 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
5738 const struct type_unit_group
*lhs
= item_lhs
;
5739 const struct type_unit_group
*rhs
= item_rhs
;
5741 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
5744 /* Allocate a hash table for type unit groups. */
5747 allocate_type_unit_groups_table (void)
5749 return htab_create_alloc_ex (3,
5750 hash_type_unit_group
,
5753 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
5754 hashtab_obstack_allocate
,
5755 dummy_obstack_deallocate
);
5758 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5759 partial symtabs. We combine several TUs per psymtab to not let the size
5760 of any one psymtab grow too big. */
5761 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5762 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5764 /* Helper routine for get_type_unit_group.
5765 Create the type_unit_group object used to hold one or more TUs. */
5767 static struct type_unit_group
*
5768 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
5770 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5771 struct dwarf2_per_cu_data
*per_cu
;
5772 struct type_unit_group
*tu_group
;
5774 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5775 struct type_unit_group
);
5776 per_cu
= &tu_group
->per_cu
;
5777 per_cu
->objfile
= objfile
;
5779 if (dwarf2_per_objfile
->using_index
)
5781 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5782 struct dwarf2_per_cu_quick_data
);
5786 unsigned int line_offset
= line_offset_struct
.sect_off
;
5787 struct partial_symtab
*pst
;
5790 /* Give the symtab a useful name for debug purposes. */
5791 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
5792 name
= xstrprintf ("<type_units_%d>",
5793 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
5795 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
5797 pst
= create_partial_symtab (per_cu
, name
);
5803 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
5804 tu_group
->hash
.line_offset
= line_offset_struct
;
5809 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5810 STMT_LIST is a DW_AT_stmt_list attribute. */
5812 static struct type_unit_group
*
5813 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
5815 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5816 struct type_unit_group
*tu_group
;
5818 unsigned int line_offset
;
5819 struct type_unit_group type_unit_group_for_lookup
;
5821 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
5823 dwarf2_per_objfile
->type_unit_groups
=
5824 allocate_type_unit_groups_table ();
5827 /* Do we need to create a new group, or can we use an existing one? */
5831 line_offset
= DW_UNSND (stmt_list
);
5832 ++tu_stats
->nr_symtab_sharers
;
5836 /* Ugh, no stmt_list. Rare, but we have to handle it.
5837 We can do various things here like create one group per TU or
5838 spread them over multiple groups to split up the expansion work.
5839 To avoid worst case scenarios (too many groups or too large groups)
5840 we, umm, group them in bunches. */
5841 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5842 | (tu_stats
->nr_stmt_less_type_units
5843 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
5844 ++tu_stats
->nr_stmt_less_type_units
;
5847 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
5848 type_unit_group_for_lookup
.hash
.line_offset
.sect_off
= line_offset
;
5849 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
5850 &type_unit_group_for_lookup
, INSERT
);
5854 gdb_assert (tu_group
!= NULL
);
5858 sect_offset line_offset_struct
;
5860 line_offset_struct
.sect_off
= line_offset
;
5861 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
5863 ++tu_stats
->nr_symtabs
;
5869 /* Partial symbol tables. */
5871 /* Create a psymtab named NAME and assign it to PER_CU.
5873 The caller must fill in the following details:
5874 dirname, textlow, texthigh. */
5876 static struct partial_symtab
*
5877 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
5879 struct objfile
*objfile
= per_cu
->objfile
;
5880 struct partial_symtab
*pst
;
5882 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
5884 objfile
->global_psymbols
.next
,
5885 objfile
->static_psymbols
.next
);
5887 pst
->psymtabs_addrmap_supported
= 1;
5889 /* This is the glue that links PST into GDB's symbol API. */
5890 pst
->read_symtab_private
= per_cu
;
5891 pst
->read_symtab
= dwarf2_read_symtab
;
5892 per_cu
->v
.psymtab
= pst
;
5897 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5900 struct process_psymtab_comp_unit_data
5902 /* True if we are reading a DW_TAG_partial_unit. */
5904 int want_partial_unit
;
5906 /* The "pretend" language that is used if the CU doesn't declare a
5909 enum language pretend_language
;
5912 /* die_reader_func for process_psymtab_comp_unit. */
5915 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
5916 const gdb_byte
*info_ptr
,
5917 struct die_info
*comp_unit_die
,
5921 struct dwarf2_cu
*cu
= reader
->cu
;
5922 struct objfile
*objfile
= cu
->objfile
;
5923 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5924 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
5925 struct attribute
*attr
;
5927 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
5928 struct partial_symtab
*pst
;
5930 const char *filename
;
5931 struct process_psymtab_comp_unit_data
*info
= data
;
5933 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
5936 gdb_assert (! per_cu
->is_debug_types
);
5938 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
5940 cu
->list_in_scope
= &file_symbols
;
5942 /* Allocate a new partial symbol table structure. */
5943 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
5944 if (attr
== NULL
|| !DW_STRING (attr
))
5947 filename
= DW_STRING (attr
);
5949 pst
= create_partial_symtab (per_cu
, filename
);
5951 /* This must be done before calling dwarf2_build_include_psymtabs. */
5952 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5954 pst
->dirname
= DW_STRING (attr
);
5956 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5958 dwarf2_find_base_address (comp_unit_die
, cu
);
5960 /* Possibly set the default values of LOWPC and HIGHPC from
5962 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
5963 &best_highpc
, cu
, pst
);
5964 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
5965 /* Store the contiguous range if it is not empty; it can be empty for
5966 CUs with no code. */
5967 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5968 gdbarch_adjust_dwarf2_addr (gdbarch
,
5969 best_lowpc
+ baseaddr
),
5970 gdbarch_adjust_dwarf2_addr (gdbarch
,
5971 best_highpc
+ baseaddr
) - 1,
5974 /* Check if comp unit has_children.
5975 If so, read the rest of the partial symbols from this comp unit.
5976 If not, there's no more debug_info for this comp unit. */
5979 struct partial_die_info
*first_die
;
5980 CORE_ADDR lowpc
, highpc
;
5982 lowpc
= ((CORE_ADDR
) -1);
5983 highpc
= ((CORE_ADDR
) 0);
5985 first_die
= load_partial_dies (reader
, info_ptr
, 1);
5987 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
5990 /* If we didn't find a lowpc, set it to highpc to avoid
5991 complaints from `maint check'. */
5992 if (lowpc
== ((CORE_ADDR
) -1))
5995 /* If the compilation unit didn't have an explicit address range,
5996 then use the information extracted from its child dies. */
6000 best_highpc
= highpc
;
6003 pst
->textlow
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
);
6004 pst
->texthigh
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
);
6006 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6007 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6008 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6009 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6010 sort_pst_symbols (objfile
, pst
);
6012 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
6015 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6016 struct dwarf2_per_cu_data
*iter
;
6018 /* Fill in 'dependencies' here; we fill in 'users' in a
6020 pst
->number_of_dependencies
= len
;
6021 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6022 len
* sizeof (struct symtab
*));
6024 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
6027 pst
->dependencies
[i
] = iter
->v
.psymtab
;
6029 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6032 /* Get the list of files included in the current compilation unit,
6033 and build a psymtab for each of them. */
6034 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
6036 if (dwarf2_read_debug
)
6038 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6040 fprintf_unfiltered (gdb_stdlog
,
6041 "Psymtab for %s unit @0x%x: %s - %s"
6042 ", %d global, %d static syms\n",
6043 per_cu
->is_debug_types
? "type" : "comp",
6044 per_cu
->offset
.sect_off
,
6045 paddress (gdbarch
, pst
->textlow
),
6046 paddress (gdbarch
, pst
->texthigh
),
6047 pst
->n_global_syms
, pst
->n_static_syms
);
6051 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6052 Process compilation unit THIS_CU for a psymtab. */
6055 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
6056 int want_partial_unit
,
6057 enum language pretend_language
)
6059 struct process_psymtab_comp_unit_data info
;
6061 /* If this compilation unit was already read in, free the
6062 cached copy in order to read it in again. This is
6063 necessary because we skipped some symbols when we first
6064 read in the compilation unit (see load_partial_dies).
6065 This problem could be avoided, but the benefit is unclear. */
6066 if (this_cu
->cu
!= NULL
)
6067 free_one_cached_comp_unit (this_cu
);
6069 gdb_assert (! this_cu
->is_debug_types
);
6070 info
.want_partial_unit
= want_partial_unit
;
6071 info
.pretend_language
= pretend_language
;
6072 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
6073 process_psymtab_comp_unit_reader
,
6076 /* Age out any secondary CUs. */
6077 age_cached_comp_units ();
6080 /* Reader function for build_type_psymtabs. */
6083 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
6084 const gdb_byte
*info_ptr
,
6085 struct die_info
*type_unit_die
,
6089 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6090 struct dwarf2_cu
*cu
= reader
->cu
;
6091 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6092 struct signatured_type
*sig_type
;
6093 struct type_unit_group
*tu_group
;
6094 struct attribute
*attr
;
6095 struct partial_die_info
*first_die
;
6096 CORE_ADDR lowpc
, highpc
;
6097 struct partial_symtab
*pst
;
6099 gdb_assert (data
== NULL
);
6100 gdb_assert (per_cu
->is_debug_types
);
6101 sig_type
= (struct signatured_type
*) per_cu
;
6106 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
6107 tu_group
= get_type_unit_group (cu
, attr
);
6109 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
6111 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
6112 cu
->list_in_scope
= &file_symbols
;
6113 pst
= create_partial_symtab (per_cu
, "");
6116 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6118 lowpc
= (CORE_ADDR
) -1;
6119 highpc
= (CORE_ADDR
) 0;
6120 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
6122 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6123 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6124 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6125 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6126 sort_pst_symbols (objfile
, pst
);
6129 /* Struct used to sort TUs by their abbreviation table offset. */
6131 struct tu_abbrev_offset
6133 struct signatured_type
*sig_type
;
6134 sect_offset abbrev_offset
;
6137 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
6140 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
6142 const struct tu_abbrev_offset
* const *a
= ap
;
6143 const struct tu_abbrev_offset
* const *b
= bp
;
6144 unsigned int aoff
= (*a
)->abbrev_offset
.sect_off
;
6145 unsigned int boff
= (*b
)->abbrev_offset
.sect_off
;
6147 return (aoff
> boff
) - (aoff
< boff
);
6150 /* Efficiently read all the type units.
6151 This does the bulk of the work for build_type_psymtabs.
6153 The efficiency is because we sort TUs by the abbrev table they use and
6154 only read each abbrev table once. In one program there are 200K TUs
6155 sharing 8K abbrev tables.
6157 The main purpose of this function is to support building the
6158 dwarf2_per_objfile->type_unit_groups table.
6159 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
6160 can collapse the search space by grouping them by stmt_list.
6161 The savings can be significant, in the same program from above the 200K TUs
6162 share 8K stmt_list tables.
6164 FUNC is expected to call get_type_unit_group, which will create the
6165 struct type_unit_group if necessary and add it to
6166 dwarf2_per_objfile->type_unit_groups. */
6169 build_type_psymtabs_1 (void)
6171 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6172 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6173 struct cleanup
*cleanups
;
6174 struct abbrev_table
*abbrev_table
;
6175 sect_offset abbrev_offset
;
6176 struct tu_abbrev_offset
*sorted_by_abbrev
;
6177 struct type_unit_group
**iter
;
6180 /* It's up to the caller to not call us multiple times. */
6181 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
6183 if (dwarf2_per_objfile
->n_type_units
== 0)
6186 /* TUs typically share abbrev tables, and there can be way more TUs than
6187 abbrev tables. Sort by abbrev table to reduce the number of times we
6188 read each abbrev table in.
6189 Alternatives are to punt or to maintain a cache of abbrev tables.
6190 This is simpler and efficient enough for now.
6192 Later we group TUs by their DW_AT_stmt_list value (as this defines the
6193 symtab to use). Typically TUs with the same abbrev offset have the same
6194 stmt_list value too so in practice this should work well.
6196 The basic algorithm here is:
6198 sort TUs by abbrev table
6199 for each TU with same abbrev table:
6200 read abbrev table if first user
6201 read TU top level DIE
6202 [IWBN if DWO skeletons had DW_AT_stmt_list]
6205 if (dwarf2_read_debug
)
6206 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
6208 /* Sort in a separate table to maintain the order of all_type_units
6209 for .gdb_index: TU indices directly index all_type_units. */
6210 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
6211 dwarf2_per_objfile
->n_type_units
);
6212 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6214 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
6216 sorted_by_abbrev
[i
].sig_type
= sig_type
;
6217 sorted_by_abbrev
[i
].abbrev_offset
=
6218 read_abbrev_offset (sig_type
->per_cu
.section
,
6219 sig_type
->per_cu
.offset
);
6221 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
6222 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
6223 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
6225 abbrev_offset
.sect_off
= ~(unsigned) 0;
6226 abbrev_table
= NULL
;
6227 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
6229 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6231 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
6233 /* Switch to the next abbrev table if necessary. */
6234 if (abbrev_table
== NULL
6235 || tu
->abbrev_offset
.sect_off
!= abbrev_offset
.sect_off
)
6237 if (abbrev_table
!= NULL
)
6239 abbrev_table_free (abbrev_table
);
6240 /* Reset to NULL in case abbrev_table_read_table throws
6241 an error: abbrev_table_free_cleanup will get called. */
6242 abbrev_table
= NULL
;
6244 abbrev_offset
= tu
->abbrev_offset
;
6246 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
6248 ++tu_stats
->nr_uniq_abbrev_tables
;
6251 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
6252 build_type_psymtabs_reader
, NULL
);
6255 do_cleanups (cleanups
);
6258 /* Print collected type unit statistics. */
6261 print_tu_stats (void)
6263 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6265 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
6266 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
6267 dwarf2_per_objfile
->n_type_units
);
6268 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
6269 tu_stats
->nr_uniq_abbrev_tables
);
6270 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
6271 tu_stats
->nr_symtabs
);
6272 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
6273 tu_stats
->nr_symtab_sharers
);
6274 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
6275 tu_stats
->nr_stmt_less_type_units
);
6276 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
6277 tu_stats
->nr_all_type_units_reallocs
);
6280 /* Traversal function for build_type_psymtabs. */
6283 build_type_psymtab_dependencies (void **slot
, void *info
)
6285 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6286 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
6287 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
6288 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6289 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
6290 struct signatured_type
*iter
;
6293 gdb_assert (len
> 0);
6294 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
6296 pst
->number_of_dependencies
= len
;
6297 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6298 len
* sizeof (struct psymtab
*));
6300 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
6303 gdb_assert (iter
->per_cu
.is_debug_types
);
6304 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
6305 iter
->type_unit_group
= tu_group
;
6308 VEC_free (sig_type_ptr
, tu_group
->tus
);
6313 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6314 Build partial symbol tables for the .debug_types comp-units. */
6317 build_type_psymtabs (struct objfile
*objfile
)
6319 if (! create_all_type_units (objfile
))
6322 build_type_psymtabs_1 ();
6325 /* Traversal function for process_skeletonless_type_unit.
6326 Read a TU in a DWO file and build partial symbols for it. */
6329 process_skeletonless_type_unit (void **slot
, void *info
)
6331 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
6332 struct objfile
*objfile
= info
;
6333 struct signatured_type find_entry
, *entry
;
6335 /* If this TU doesn't exist in the global table, add it and read it in. */
6337 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6339 dwarf2_per_objfile
->signatured_types
6340 = allocate_signatured_type_table (objfile
);
6343 find_entry
.signature
= dwo_unit
->signature
;
6344 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
6346 /* If we've already seen this type there's nothing to do. What's happening
6347 is we're doing our own version of comdat-folding here. */
6351 /* This does the job that create_all_type_units would have done for
6353 entry
= add_type_unit (dwo_unit
->signature
, slot
);
6354 fill_in_sig_entry_from_dwo_entry (objfile
, entry
, dwo_unit
);
6357 /* This does the job that build_type_psymtabs_1 would have done. */
6358 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0,
6359 build_type_psymtabs_reader
, NULL
);
6364 /* Traversal function for process_skeletonless_type_units. */
6367 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
6369 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
6371 if (dwo_file
->tus
!= NULL
)
6373 htab_traverse_noresize (dwo_file
->tus
,
6374 process_skeletonless_type_unit
, info
);
6380 /* Scan all TUs of DWO files, verifying we've processed them.
6381 This is needed in case a TU was emitted without its skeleton.
6382 Note: This can't be done until we know what all the DWO files are. */
6385 process_skeletonless_type_units (struct objfile
*objfile
)
6387 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
6388 if (get_dwp_file () == NULL
6389 && dwarf2_per_objfile
->dwo_files
!= NULL
)
6391 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
,
6392 process_dwo_file_for_skeletonless_type_units
,
6397 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6400 psymtabs_addrmap_cleanup (void *o
)
6402 struct objfile
*objfile
= o
;
6404 objfile
->psymtabs_addrmap
= NULL
;
6407 /* Compute the 'user' field for each psymtab in OBJFILE. */
6410 set_partial_user (struct objfile
*objfile
)
6414 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6416 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6417 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6423 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
6425 /* Set the 'user' field only if it is not already set. */
6426 if (pst
->dependencies
[j
]->user
== NULL
)
6427 pst
->dependencies
[j
]->user
= pst
;
6432 /* Build the partial symbol table by doing a quick pass through the
6433 .debug_info and .debug_abbrev sections. */
6436 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
6438 struct cleanup
*back_to
, *addrmap_cleanup
;
6439 struct obstack temp_obstack
;
6442 if (dwarf2_read_debug
)
6444 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
6445 objfile_name (objfile
));
6448 dwarf2_per_objfile
->reading_partial_symbols
= 1;
6450 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
6452 /* Any cached compilation units will be linked by the per-objfile
6453 read_in_chain. Make sure to free them when we're done. */
6454 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
6456 build_type_psymtabs (objfile
);
6458 create_all_comp_units (objfile
);
6460 /* Create a temporary address map on a temporary obstack. We later
6461 copy this to the final obstack. */
6462 obstack_init (&temp_obstack
);
6463 make_cleanup_obstack_free (&temp_obstack
);
6464 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
6465 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
6467 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6469 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6471 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
6474 /* This has to wait until we read the CUs, we need the list of DWOs. */
6475 process_skeletonless_type_units (objfile
);
6477 /* Now that all TUs have been processed we can fill in the dependencies. */
6478 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
6480 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
6481 build_type_psymtab_dependencies
, NULL
);
6484 if (dwarf2_read_debug
)
6487 set_partial_user (objfile
);
6489 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
6490 &objfile
->objfile_obstack
);
6491 discard_cleanups (addrmap_cleanup
);
6493 do_cleanups (back_to
);
6495 if (dwarf2_read_debug
)
6496 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
6497 objfile_name (objfile
));
6500 /* die_reader_func for load_partial_comp_unit. */
6503 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
6504 const gdb_byte
*info_ptr
,
6505 struct die_info
*comp_unit_die
,
6509 struct dwarf2_cu
*cu
= reader
->cu
;
6511 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
6513 /* Check if comp unit has_children.
6514 If so, read the rest of the partial symbols from this comp unit.
6515 If not, there's no more debug_info for this comp unit. */
6517 load_partial_dies (reader
, info_ptr
, 0);
6520 /* Load the partial DIEs for a secondary CU into memory.
6521 This is also used when rereading a primary CU with load_all_dies. */
6524 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
6526 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
6527 load_partial_comp_unit_reader
, NULL
);
6531 read_comp_units_from_section (struct objfile
*objfile
,
6532 struct dwarf2_section_info
*section
,
6533 unsigned int is_dwz
,
6536 struct dwarf2_per_cu_data
***all_comp_units
)
6538 const gdb_byte
*info_ptr
;
6539 bfd
*abfd
= get_section_bfd_owner (section
);
6541 if (dwarf2_read_debug
)
6542 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
6543 get_section_name (section
),
6544 get_section_file_name (section
));
6546 dwarf2_read_section (objfile
, section
);
6548 info_ptr
= section
->buffer
;
6550 while (info_ptr
< section
->buffer
+ section
->size
)
6552 unsigned int length
, initial_length_size
;
6553 struct dwarf2_per_cu_data
*this_cu
;
6556 offset
.sect_off
= info_ptr
- section
->buffer
;
6558 /* Read just enough information to find out where the next
6559 compilation unit is. */
6560 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6562 /* Save the compilation unit for later lookup. */
6563 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
6564 sizeof (struct dwarf2_per_cu_data
));
6565 memset (this_cu
, 0, sizeof (*this_cu
));
6566 this_cu
->offset
= offset
;
6567 this_cu
->length
= length
+ initial_length_size
;
6568 this_cu
->is_dwz
= is_dwz
;
6569 this_cu
->objfile
= objfile
;
6570 this_cu
->section
= section
;
6572 if (*n_comp_units
== *n_allocated
)
6575 *all_comp_units
= xrealloc (*all_comp_units
,
6577 * sizeof (struct dwarf2_per_cu_data
*));
6579 (*all_comp_units
)[*n_comp_units
] = this_cu
;
6582 info_ptr
= info_ptr
+ this_cu
->length
;
6586 /* Create a list of all compilation units in OBJFILE.
6587 This is only done for -readnow and building partial symtabs. */
6590 create_all_comp_units (struct objfile
*objfile
)
6594 struct dwarf2_per_cu_data
**all_comp_units
;
6595 struct dwz_file
*dwz
;
6599 all_comp_units
= xmalloc (n_allocated
6600 * sizeof (struct dwarf2_per_cu_data
*));
6602 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
, 0,
6603 &n_allocated
, &n_comp_units
, &all_comp_units
);
6605 dwz
= dwarf2_get_dwz_file ();
6607 read_comp_units_from_section (objfile
, &dwz
->info
, 1,
6608 &n_allocated
, &n_comp_units
,
6611 dwarf2_per_objfile
->all_comp_units
6612 = obstack_alloc (&objfile
->objfile_obstack
,
6613 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6614 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
6615 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6616 xfree (all_comp_units
);
6617 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
6620 /* Process all loaded DIEs for compilation unit CU, starting at
6621 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
6622 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6623 DW_AT_ranges). See the comments of add_partial_subprogram on how
6624 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
6627 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
6628 CORE_ADDR
*highpc
, int set_addrmap
,
6629 struct dwarf2_cu
*cu
)
6631 struct partial_die_info
*pdi
;
6633 /* Now, march along the PDI's, descending into ones which have
6634 interesting children but skipping the children of the other ones,
6635 until we reach the end of the compilation unit. */
6641 fixup_partial_die (pdi
, cu
);
6643 /* Anonymous namespaces or modules have no name but have interesting
6644 children, so we need to look at them. Ditto for anonymous
6647 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
6648 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
6649 || pdi
->tag
== DW_TAG_imported_unit
)
6653 case DW_TAG_subprogram
:
6654 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6656 case DW_TAG_constant
:
6657 case DW_TAG_variable
:
6658 case DW_TAG_typedef
:
6659 case DW_TAG_union_type
:
6660 if (!pdi
->is_declaration
)
6662 add_partial_symbol (pdi
, cu
);
6665 case DW_TAG_class_type
:
6666 case DW_TAG_interface_type
:
6667 case DW_TAG_structure_type
:
6668 if (!pdi
->is_declaration
)
6670 add_partial_symbol (pdi
, cu
);
6673 case DW_TAG_enumeration_type
:
6674 if (!pdi
->is_declaration
)
6675 add_partial_enumeration (pdi
, cu
);
6677 case DW_TAG_base_type
:
6678 case DW_TAG_subrange_type
:
6679 /* File scope base type definitions are added to the partial
6681 add_partial_symbol (pdi
, cu
);
6683 case DW_TAG_namespace
:
6684 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6687 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6689 case DW_TAG_imported_unit
:
6691 struct dwarf2_per_cu_data
*per_cu
;
6693 /* For now we don't handle imported units in type units. */
6694 if (cu
->per_cu
->is_debug_types
)
6696 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6697 " supported in type units [in module %s]"),
6698 objfile_name (cu
->objfile
));
6701 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
6705 /* Go read the partial unit, if needed. */
6706 if (per_cu
->v
.psymtab
== NULL
)
6707 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
6709 VEC_safe_push (dwarf2_per_cu_ptr
,
6710 cu
->per_cu
->imported_symtabs
, per_cu
);
6713 case DW_TAG_imported_declaration
:
6714 add_partial_symbol (pdi
, cu
);
6721 /* If the die has a sibling, skip to the sibling. */
6723 pdi
= pdi
->die_sibling
;
6727 /* Functions used to compute the fully scoped name of a partial DIE.
6729 Normally, this is simple. For C++, the parent DIE's fully scoped
6730 name is concatenated with "::" and the partial DIE's name. For
6731 Java, the same thing occurs except that "." is used instead of "::".
6732 Enumerators are an exception; they use the scope of their parent
6733 enumeration type, i.e. the name of the enumeration type is not
6734 prepended to the enumerator.
6736 There are two complexities. One is DW_AT_specification; in this
6737 case "parent" means the parent of the target of the specification,
6738 instead of the direct parent of the DIE. The other is compilers
6739 which do not emit DW_TAG_namespace; in this case we try to guess
6740 the fully qualified name of structure types from their members'
6741 linkage names. This must be done using the DIE's children rather
6742 than the children of any DW_AT_specification target. We only need
6743 to do this for structures at the top level, i.e. if the target of
6744 any DW_AT_specification (if any; otherwise the DIE itself) does not
6747 /* Compute the scope prefix associated with PDI's parent, in
6748 compilation unit CU. The result will be allocated on CU's
6749 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6750 field. NULL is returned if no prefix is necessary. */
6752 partial_die_parent_scope (struct partial_die_info
*pdi
,
6753 struct dwarf2_cu
*cu
)
6755 const char *grandparent_scope
;
6756 struct partial_die_info
*parent
, *real_pdi
;
6758 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6759 then this means the parent of the specification DIE. */
6762 while (real_pdi
->has_specification
)
6763 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
6764 real_pdi
->spec_is_dwz
, cu
);
6766 parent
= real_pdi
->die_parent
;
6770 if (parent
->scope_set
)
6771 return parent
->scope
;
6773 fixup_partial_die (parent
, cu
);
6775 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
6777 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6778 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6779 Work around this problem here. */
6780 if (cu
->language
== language_cplus
6781 && parent
->tag
== DW_TAG_namespace
6782 && strcmp (parent
->name
, "::") == 0
6783 && grandparent_scope
== NULL
)
6785 parent
->scope
= NULL
;
6786 parent
->scope_set
= 1;
6790 if (pdi
->tag
== DW_TAG_enumerator
)
6791 /* Enumerators should not get the name of the enumeration as a prefix. */
6792 parent
->scope
= grandparent_scope
;
6793 else if (parent
->tag
== DW_TAG_namespace
6794 || parent
->tag
== DW_TAG_module
6795 || parent
->tag
== DW_TAG_structure_type
6796 || parent
->tag
== DW_TAG_class_type
6797 || parent
->tag
== DW_TAG_interface_type
6798 || parent
->tag
== DW_TAG_union_type
6799 || parent
->tag
== DW_TAG_enumeration_type
)
6801 if (grandparent_scope
== NULL
)
6802 parent
->scope
= parent
->name
;
6804 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
6806 parent
->name
, 0, cu
);
6810 /* FIXME drow/2004-04-01: What should we be doing with
6811 function-local names? For partial symbols, we should probably be
6813 complaint (&symfile_complaints
,
6814 _("unhandled containing DIE tag %d for DIE at %d"),
6815 parent
->tag
, pdi
->offset
.sect_off
);
6816 parent
->scope
= grandparent_scope
;
6819 parent
->scope_set
= 1;
6820 return parent
->scope
;
6823 /* Return the fully scoped name associated with PDI, from compilation unit
6824 CU. The result will be allocated with malloc. */
6827 partial_die_full_name (struct partial_die_info
*pdi
,
6828 struct dwarf2_cu
*cu
)
6830 const char *parent_scope
;
6832 /* If this is a template instantiation, we can not work out the
6833 template arguments from partial DIEs. So, unfortunately, we have
6834 to go through the full DIEs. At least any work we do building
6835 types here will be reused if full symbols are loaded later. */
6836 if (pdi
->has_template_arguments
)
6838 fixup_partial_die (pdi
, cu
);
6840 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
6842 struct die_info
*die
;
6843 struct attribute attr
;
6844 struct dwarf2_cu
*ref_cu
= cu
;
6846 /* DW_FORM_ref_addr is using section offset. */
6848 attr
.form
= DW_FORM_ref_addr
;
6849 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
6850 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
6852 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
6856 parent_scope
= partial_die_parent_scope (pdi
, cu
);
6857 if (parent_scope
== NULL
)
6860 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
6864 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
6866 struct objfile
*objfile
= cu
->objfile
;
6867 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6869 const char *actual_name
= NULL
;
6871 char *built_actual_name
;
6873 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6875 built_actual_name
= partial_die_full_name (pdi
, cu
);
6876 if (built_actual_name
!= NULL
)
6877 actual_name
= built_actual_name
;
6879 if (actual_name
== NULL
)
6880 actual_name
= pdi
->name
;
6884 case DW_TAG_subprogram
:
6885 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
);
6886 if (pdi
->is_external
|| cu
->language
== language_ada
)
6888 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6889 of the global scope. But in Ada, we want to be able to access
6890 nested procedures globally. So all Ada subprograms are stored
6891 in the global scope. */
6892 /* prim_record_minimal_symbol (actual_name, addr, mst_text,
6894 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6895 built_actual_name
!= NULL
,
6896 VAR_DOMAIN
, LOC_BLOCK
,
6897 &objfile
->global_psymbols
,
6898 0, addr
, cu
->language
, objfile
);
6902 /* prim_record_minimal_symbol (actual_name, addr, mst_file_text,
6904 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6905 built_actual_name
!= NULL
,
6906 VAR_DOMAIN
, LOC_BLOCK
,
6907 &objfile
->static_psymbols
,
6908 0, addr
, cu
->language
, objfile
);
6911 case DW_TAG_constant
:
6913 struct psymbol_allocation_list
*list
;
6915 if (pdi
->is_external
)
6916 list
= &objfile
->global_psymbols
;
6918 list
= &objfile
->static_psymbols
;
6919 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6920 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
6921 list
, 0, 0, cu
->language
, objfile
);
6924 case DW_TAG_variable
:
6926 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
6930 && !dwarf2_per_objfile
->has_section_at_zero
)
6932 /* A global or static variable may also have been stripped
6933 out by the linker if unused, in which case its address
6934 will be nullified; do not add such variables into partial
6935 symbol table then. */
6937 else if (pdi
->is_external
)
6940 Don't enter into the minimal symbol tables as there is
6941 a minimal symbol table entry from the ELF symbols already.
6942 Enter into partial symbol table if it has a location
6943 descriptor or a type.
6944 If the location descriptor is missing, new_symbol will create
6945 a LOC_UNRESOLVED symbol, the address of the variable will then
6946 be determined from the minimal symbol table whenever the variable
6948 The address for the partial symbol table entry is not
6949 used by GDB, but it comes in handy for debugging partial symbol
6952 if (pdi
->d
.locdesc
|| pdi
->has_type
)
6953 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6954 built_actual_name
!= NULL
,
6955 VAR_DOMAIN
, LOC_STATIC
,
6956 &objfile
->global_psymbols
,
6958 cu
->language
, objfile
);
6962 int has_loc
= pdi
->d
.locdesc
!= NULL
;
6964 /* Static Variable. Skip symbols whose value we cannot know (those
6965 without location descriptors or constant values). */
6966 if (!has_loc
&& !pdi
->has_const_value
)
6968 xfree (built_actual_name
);
6972 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6973 mst_file_data, objfile); */
6974 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6975 built_actual_name
!= NULL
,
6976 VAR_DOMAIN
, LOC_STATIC
,
6977 &objfile
->static_psymbols
,
6979 has_loc
? addr
+ baseaddr
: (CORE_ADDR
) 0,
6980 cu
->language
, objfile
);
6983 case DW_TAG_typedef
:
6984 case DW_TAG_base_type
:
6985 case DW_TAG_subrange_type
:
6986 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6987 built_actual_name
!= NULL
,
6988 VAR_DOMAIN
, LOC_TYPEDEF
,
6989 &objfile
->static_psymbols
,
6990 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6992 case DW_TAG_imported_declaration
:
6993 case DW_TAG_namespace
:
6994 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6995 built_actual_name
!= NULL
,
6996 VAR_DOMAIN
, LOC_TYPEDEF
,
6997 &objfile
->global_psymbols
,
6998 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7001 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7002 built_actual_name
!= NULL
,
7003 MODULE_DOMAIN
, LOC_TYPEDEF
,
7004 &objfile
->global_psymbols
,
7005 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7007 case DW_TAG_class_type
:
7008 case DW_TAG_interface_type
:
7009 case DW_TAG_structure_type
:
7010 case DW_TAG_union_type
:
7011 case DW_TAG_enumeration_type
:
7012 /* Skip external references. The DWARF standard says in the section
7013 about "Structure, Union, and Class Type Entries": "An incomplete
7014 structure, union or class type is represented by a structure,
7015 union or class entry that does not have a byte size attribute
7016 and that has a DW_AT_declaration attribute." */
7017 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
7019 xfree (built_actual_name
);
7023 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
7024 static vs. global. */
7025 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7026 built_actual_name
!= NULL
,
7027 STRUCT_DOMAIN
, LOC_TYPEDEF
,
7028 (cu
->language
== language_cplus
7029 || cu
->language
== language_java
)
7030 ? &objfile
->global_psymbols
7031 : &objfile
->static_psymbols
,
7032 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7035 case DW_TAG_enumerator
:
7036 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7037 built_actual_name
!= NULL
,
7038 VAR_DOMAIN
, LOC_CONST
,
7039 (cu
->language
== language_cplus
7040 || cu
->language
== language_java
)
7041 ? &objfile
->global_psymbols
7042 : &objfile
->static_psymbols
,
7043 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7049 xfree (built_actual_name
);
7052 /* Read a partial die corresponding to a namespace; also, add a symbol
7053 corresponding to that namespace to the symbol table. NAMESPACE is
7054 the name of the enclosing namespace. */
7057 add_partial_namespace (struct partial_die_info
*pdi
,
7058 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7059 int set_addrmap
, struct dwarf2_cu
*cu
)
7061 /* Add a symbol for the namespace. */
7063 add_partial_symbol (pdi
, cu
);
7065 /* Now scan partial symbols in that namespace. */
7067 if (pdi
->has_children
)
7068 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7071 /* Read a partial die corresponding to a Fortran module. */
7074 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
7075 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
7077 /* Add a symbol for the namespace. */
7079 add_partial_symbol (pdi
, cu
);
7081 /* Now scan partial symbols in that module. */
7083 if (pdi
->has_children
)
7084 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7087 /* Read a partial die corresponding to a subprogram and create a partial
7088 symbol for that subprogram. When the CU language allows it, this
7089 routine also defines a partial symbol for each nested subprogram
7090 that this subprogram contains. If SET_ADDRMAP is true, record the
7091 covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
7092 and highest PC values found in PDI.
7094 PDI may also be a lexical block, in which case we simply search
7095 recursively for subprograms defined inside that lexical block.
7096 Again, this is only performed when the CU language allows this
7097 type of definitions. */
7100 add_partial_subprogram (struct partial_die_info
*pdi
,
7101 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7102 int set_addrmap
, struct dwarf2_cu
*cu
)
7104 if (pdi
->tag
== DW_TAG_subprogram
)
7106 if (pdi
->has_pc_info
)
7108 if (pdi
->lowpc
< *lowpc
)
7109 *lowpc
= pdi
->lowpc
;
7110 if (pdi
->highpc
> *highpc
)
7111 *highpc
= pdi
->highpc
;
7114 struct objfile
*objfile
= cu
->objfile
;
7115 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7120 baseaddr
= ANOFFSET (objfile
->section_offsets
,
7121 SECT_OFF_TEXT (objfile
));
7122 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7123 pdi
->lowpc
+ baseaddr
);
7124 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7125 pdi
->highpc
+ baseaddr
);
7126 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
7127 cu
->per_cu
->v
.psymtab
);
7131 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
7133 if (!pdi
->is_declaration
)
7134 /* Ignore subprogram DIEs that do not have a name, they are
7135 illegal. Do not emit a complaint at this point, we will
7136 do so when we convert this psymtab into a symtab. */
7138 add_partial_symbol (pdi
, cu
);
7142 if (! pdi
->has_children
)
7145 if (cu
->language
== language_ada
)
7147 pdi
= pdi
->die_child
;
7150 fixup_partial_die (pdi
, cu
);
7151 if (pdi
->tag
== DW_TAG_subprogram
7152 || pdi
->tag
== DW_TAG_lexical_block
)
7153 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7154 pdi
= pdi
->die_sibling
;
7159 /* Read a partial die corresponding to an enumeration type. */
7162 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
7163 struct dwarf2_cu
*cu
)
7165 struct partial_die_info
*pdi
;
7167 if (enum_pdi
->name
!= NULL
)
7168 add_partial_symbol (enum_pdi
, cu
);
7170 pdi
= enum_pdi
->die_child
;
7173 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
7174 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
7176 add_partial_symbol (pdi
, cu
);
7177 pdi
= pdi
->die_sibling
;
7181 /* Return the initial uleb128 in the die at INFO_PTR. */
7184 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
7186 unsigned int bytes_read
;
7188 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7191 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7192 Return the corresponding abbrev, or NULL if the number is zero (indicating
7193 an empty DIE). In either case *BYTES_READ will be set to the length of
7194 the initial number. */
7196 static struct abbrev_info
*
7197 peek_die_abbrev (const gdb_byte
*info_ptr
, unsigned int *bytes_read
,
7198 struct dwarf2_cu
*cu
)
7200 bfd
*abfd
= cu
->objfile
->obfd
;
7201 unsigned int abbrev_number
;
7202 struct abbrev_info
*abbrev
;
7204 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
7206 if (abbrev_number
== 0)
7209 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
7212 error (_("Dwarf Error: Could not find abbrev number %d in %s"
7213 " at offset 0x%x [in module %s]"),
7214 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
7215 cu
->header
.offset
.sect_off
, bfd_get_filename (abfd
));
7221 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7222 Returns a pointer to the end of a series of DIEs, terminated by an empty
7223 DIE. Any children of the skipped DIEs will also be skipped. */
7225 static const gdb_byte
*
7226 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
7228 struct dwarf2_cu
*cu
= reader
->cu
;
7229 struct abbrev_info
*abbrev
;
7230 unsigned int bytes_read
;
7234 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
7236 return info_ptr
+ bytes_read
;
7238 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
7242 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7243 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7244 abbrev corresponding to that skipped uleb128 should be passed in
7245 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7248 static const gdb_byte
*
7249 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
7250 struct abbrev_info
*abbrev
)
7252 unsigned int bytes_read
;
7253 struct attribute attr
;
7254 bfd
*abfd
= reader
->abfd
;
7255 struct dwarf2_cu
*cu
= reader
->cu
;
7256 const gdb_byte
*buffer
= reader
->buffer
;
7257 const gdb_byte
*buffer_end
= reader
->buffer_end
;
7258 const gdb_byte
*start_info_ptr
= info_ptr
;
7259 unsigned int form
, i
;
7261 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
7263 /* The only abbrev we care about is DW_AT_sibling. */
7264 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
7266 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
7267 if (attr
.form
== DW_FORM_ref_addr
)
7268 complaint (&symfile_complaints
,
7269 _("ignoring absolute DW_AT_sibling"));
7272 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
7273 const gdb_byte
*sibling_ptr
= buffer
+ off
;
7275 if (sibling_ptr
< info_ptr
)
7276 complaint (&symfile_complaints
,
7277 _("DW_AT_sibling points backwards"));
7278 else if (sibling_ptr
> reader
->buffer_end
)
7279 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
7285 /* If it isn't DW_AT_sibling, skip this attribute. */
7286 form
= abbrev
->attrs
[i
].form
;
7290 case DW_FORM_ref_addr
:
7291 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7292 and later it is offset sized. */
7293 if (cu
->header
.version
== 2)
7294 info_ptr
+= cu
->header
.addr_size
;
7296 info_ptr
+= cu
->header
.offset_size
;
7298 case DW_FORM_GNU_ref_alt
:
7299 info_ptr
+= cu
->header
.offset_size
;
7302 info_ptr
+= cu
->header
.addr_size
;
7309 case DW_FORM_flag_present
:
7321 case DW_FORM_ref_sig8
:
7324 case DW_FORM_string
:
7325 read_direct_string (abfd
, info_ptr
, &bytes_read
);
7326 info_ptr
+= bytes_read
;
7328 case DW_FORM_sec_offset
:
7330 case DW_FORM_GNU_strp_alt
:
7331 info_ptr
+= cu
->header
.offset_size
;
7333 case DW_FORM_exprloc
:
7335 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7336 info_ptr
+= bytes_read
;
7338 case DW_FORM_block1
:
7339 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
7341 case DW_FORM_block2
:
7342 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
7344 case DW_FORM_block4
:
7345 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
7349 case DW_FORM_ref_udata
:
7350 case DW_FORM_GNU_addr_index
:
7351 case DW_FORM_GNU_str_index
:
7352 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
7354 case DW_FORM_indirect
:
7355 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7356 info_ptr
+= bytes_read
;
7357 /* We need to continue parsing from here, so just go back to
7359 goto skip_attribute
;
7362 error (_("Dwarf Error: Cannot handle %s "
7363 "in DWARF reader [in module %s]"),
7364 dwarf_form_name (form
),
7365 bfd_get_filename (abfd
));
7369 if (abbrev
->has_children
)
7370 return skip_children (reader
, info_ptr
);
7375 /* Locate ORIG_PDI's sibling.
7376 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7378 static const gdb_byte
*
7379 locate_pdi_sibling (const struct die_reader_specs
*reader
,
7380 struct partial_die_info
*orig_pdi
,
7381 const gdb_byte
*info_ptr
)
7383 /* Do we know the sibling already? */
7385 if (orig_pdi
->sibling
)
7386 return orig_pdi
->sibling
;
7388 /* Are there any children to deal with? */
7390 if (!orig_pdi
->has_children
)
7393 /* Skip the children the long way. */
7395 return skip_children (reader
, info_ptr
);
7398 /* Expand this partial symbol table into a full symbol table. SELF is
7402 dwarf2_read_symtab (struct partial_symtab
*self
,
7403 struct objfile
*objfile
)
7407 warning (_("bug: psymtab for %s is already read in."),
7414 printf_filtered (_("Reading in symbols for %s..."),
7416 gdb_flush (gdb_stdout
);
7419 /* Restore our global data. */
7420 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
7422 /* If this psymtab is constructed from a debug-only objfile, the
7423 has_section_at_zero flag will not necessarily be correct. We
7424 can get the correct value for this flag by looking at the data
7425 associated with the (presumably stripped) associated objfile. */
7426 if (objfile
->separate_debug_objfile_backlink
)
7428 struct dwarf2_per_objfile
*dpo_backlink
7429 = objfile_data (objfile
->separate_debug_objfile_backlink
,
7430 dwarf2_objfile_data_key
);
7432 dwarf2_per_objfile
->has_section_at_zero
7433 = dpo_backlink
->has_section_at_zero
;
7436 dwarf2_per_objfile
->reading_partial_symbols
= 0;
7438 psymtab_to_symtab_1 (self
);
7440 /* Finish up the debug error message. */
7442 printf_filtered (_("done.\n"));
7445 process_cu_includes ();
7448 /* Reading in full CUs. */
7450 /* Add PER_CU to the queue. */
7453 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
7454 enum language pretend_language
)
7456 struct dwarf2_queue_item
*item
;
7459 item
= xmalloc (sizeof (*item
));
7460 item
->per_cu
= per_cu
;
7461 item
->pretend_language
= pretend_language
;
7464 if (dwarf2_queue
== NULL
)
7465 dwarf2_queue
= item
;
7467 dwarf2_queue_tail
->next
= item
;
7469 dwarf2_queue_tail
= item
;
7472 /* If PER_CU is not yet queued, add it to the queue.
7473 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7475 The result is non-zero if PER_CU was queued, otherwise the result is zero
7476 meaning either PER_CU is already queued or it is already loaded.
7478 N.B. There is an invariant here that if a CU is queued then it is loaded.
7479 The caller is required to load PER_CU if we return non-zero. */
7482 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
7483 struct dwarf2_per_cu_data
*per_cu
,
7484 enum language pretend_language
)
7486 /* We may arrive here during partial symbol reading, if we need full
7487 DIEs to process an unusual case (e.g. template arguments). Do
7488 not queue PER_CU, just tell our caller to load its DIEs. */
7489 if (dwarf2_per_objfile
->reading_partial_symbols
)
7491 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
7496 /* Mark the dependence relation so that we don't flush PER_CU
7498 if (dependent_cu
!= NULL
)
7499 dwarf2_add_dependence (dependent_cu
, per_cu
);
7501 /* If it's already on the queue, we have nothing to do. */
7505 /* If the compilation unit is already loaded, just mark it as
7507 if (per_cu
->cu
!= NULL
)
7509 per_cu
->cu
->last_used
= 0;
7513 /* Add it to the queue. */
7514 queue_comp_unit (per_cu
, pretend_language
);
7519 /* Process the queue. */
7522 process_queue (void)
7524 struct dwarf2_queue_item
*item
, *next_item
;
7526 if (dwarf2_read_debug
)
7528 fprintf_unfiltered (gdb_stdlog
,
7529 "Expanding one or more symtabs of objfile %s ...\n",
7530 objfile_name (dwarf2_per_objfile
->objfile
));
7533 /* The queue starts out with one item, but following a DIE reference
7534 may load a new CU, adding it to the end of the queue. */
7535 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
7537 if (dwarf2_per_objfile
->using_index
7538 ? !item
->per_cu
->v
.quick
->compunit_symtab
7539 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
7541 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
7542 unsigned int debug_print_threshold
;
7545 if (per_cu
->is_debug_types
)
7547 struct signatured_type
*sig_type
=
7548 (struct signatured_type
*) per_cu
;
7550 sprintf (buf
, "TU %s at offset 0x%x",
7551 hex_string (sig_type
->signature
),
7552 per_cu
->offset
.sect_off
);
7553 /* There can be 100s of TUs.
7554 Only print them in verbose mode. */
7555 debug_print_threshold
= 2;
7559 sprintf (buf
, "CU at offset 0x%x", per_cu
->offset
.sect_off
);
7560 debug_print_threshold
= 1;
7563 if (dwarf2_read_debug
>= debug_print_threshold
)
7564 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
7566 if (per_cu
->is_debug_types
)
7567 process_full_type_unit (per_cu
, item
->pretend_language
);
7569 process_full_comp_unit (per_cu
, item
->pretend_language
);
7571 if (dwarf2_read_debug
>= debug_print_threshold
)
7572 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
7575 item
->per_cu
->queued
= 0;
7576 next_item
= item
->next
;
7580 dwarf2_queue_tail
= NULL
;
7582 if (dwarf2_read_debug
)
7584 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
7585 objfile_name (dwarf2_per_objfile
->objfile
));
7589 /* Free all allocated queue entries. This function only releases anything if
7590 an error was thrown; if the queue was processed then it would have been
7591 freed as we went along. */
7594 dwarf2_release_queue (void *dummy
)
7596 struct dwarf2_queue_item
*item
, *last
;
7598 item
= dwarf2_queue
;
7601 /* Anything still marked queued is likely to be in an
7602 inconsistent state, so discard it. */
7603 if (item
->per_cu
->queued
)
7605 if (item
->per_cu
->cu
!= NULL
)
7606 free_one_cached_comp_unit (item
->per_cu
);
7607 item
->per_cu
->queued
= 0;
7615 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
7618 /* Read in full symbols for PST, and anything it depends on. */
7621 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
7623 struct dwarf2_per_cu_data
*per_cu
;
7629 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
7630 if (!pst
->dependencies
[i
]->readin
7631 && pst
->dependencies
[i
]->user
== NULL
)
7633 /* Inform about additional files that need to be read in. */
7636 /* FIXME: i18n: Need to make this a single string. */
7637 fputs_filtered (" ", gdb_stdout
);
7639 fputs_filtered ("and ", gdb_stdout
);
7641 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
7642 wrap_here (""); /* Flush output. */
7643 gdb_flush (gdb_stdout
);
7645 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
7648 per_cu
= pst
->read_symtab_private
;
7652 /* It's an include file, no symbols to read for it.
7653 Everything is in the parent symtab. */
7658 dw2_do_instantiate_symtab (per_cu
);
7661 /* Trivial hash function for die_info: the hash value of a DIE
7662 is its offset in .debug_info for this objfile. */
7665 die_hash (const void *item
)
7667 const struct die_info
*die
= item
;
7669 return die
->offset
.sect_off
;
7672 /* Trivial comparison function for die_info structures: two DIEs
7673 are equal if they have the same offset. */
7676 die_eq (const void *item_lhs
, const void *item_rhs
)
7678 const struct die_info
*die_lhs
= item_lhs
;
7679 const struct die_info
*die_rhs
= item_rhs
;
7681 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
7684 /* die_reader_func for load_full_comp_unit.
7685 This is identical to read_signatured_type_reader,
7686 but is kept separate for now. */
7689 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
7690 const gdb_byte
*info_ptr
,
7691 struct die_info
*comp_unit_die
,
7695 struct dwarf2_cu
*cu
= reader
->cu
;
7696 enum language
*language_ptr
= data
;
7698 gdb_assert (cu
->die_hash
== NULL
);
7700 htab_create_alloc_ex (cu
->header
.length
/ 12,
7704 &cu
->comp_unit_obstack
,
7705 hashtab_obstack_allocate
,
7706 dummy_obstack_deallocate
);
7709 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
7710 &info_ptr
, comp_unit_die
);
7711 cu
->dies
= comp_unit_die
;
7712 /* comp_unit_die is not stored in die_hash, no need. */
7714 /* We try not to read any attributes in this function, because not
7715 all CUs needed for references have been loaded yet, and symbol
7716 table processing isn't initialized. But we have to set the CU language,
7717 or we won't be able to build types correctly.
7718 Similarly, if we do not read the producer, we can not apply
7719 producer-specific interpretation. */
7720 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
7723 /* Load the DIEs associated with PER_CU into memory. */
7726 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7727 enum language pretend_language
)
7729 gdb_assert (! this_cu
->is_debug_types
);
7731 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
7732 load_full_comp_unit_reader
, &pretend_language
);
7735 /* Add a DIE to the delayed physname list. */
7738 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
7739 const char *name
, struct die_info
*die
,
7740 struct dwarf2_cu
*cu
)
7742 struct delayed_method_info mi
;
7744 mi
.fnfield_index
= fnfield_index
;
7748 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
7751 /* A cleanup for freeing the delayed method list. */
7754 free_delayed_list (void *ptr
)
7756 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
7757 if (cu
->method_list
!= NULL
)
7759 VEC_free (delayed_method_info
, cu
->method_list
);
7760 cu
->method_list
= NULL
;
7764 /* Compute the physnames of any methods on the CU's method list.
7766 The computation of method physnames is delayed in order to avoid the
7767 (bad) condition that one of the method's formal parameters is of an as yet
7771 compute_delayed_physnames (struct dwarf2_cu
*cu
)
7774 struct delayed_method_info
*mi
;
7775 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
7777 const char *physname
;
7778 struct fn_fieldlist
*fn_flp
7779 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
7780 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
7781 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
->index
)
7782 = physname
? physname
: "";
7786 /* Go objects should be embedded in a DW_TAG_module DIE,
7787 and it's not clear if/how imported objects will appear.
7788 To keep Go support simple until that's worked out,
7789 go back through what we've read and create something usable.
7790 We could do this while processing each DIE, and feels kinda cleaner,
7791 but that way is more invasive.
7792 This is to, for example, allow the user to type "p var" or "b main"
7793 without having to specify the package name, and allow lookups
7794 of module.object to work in contexts that use the expression
7798 fixup_go_packaging (struct dwarf2_cu
*cu
)
7800 char *package_name
= NULL
;
7801 struct pending
*list
;
7804 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
7806 for (i
= 0; i
< list
->nsyms
; ++i
)
7808 struct symbol
*sym
= list
->symbol
[i
];
7810 if (SYMBOL_LANGUAGE (sym
) == language_go
7811 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
7813 char *this_package_name
= go_symbol_package_name (sym
);
7815 if (this_package_name
== NULL
)
7817 if (package_name
== NULL
)
7818 package_name
= this_package_name
;
7821 if (strcmp (package_name
, this_package_name
) != 0)
7822 complaint (&symfile_complaints
,
7823 _("Symtab %s has objects from two different Go packages: %s and %s"),
7824 (symbol_symtab (sym
) != NULL
7825 ? symtab_to_filename_for_display
7826 (symbol_symtab (sym
))
7827 : objfile_name (cu
->objfile
)),
7828 this_package_name
, package_name
);
7829 xfree (this_package_name
);
7835 if (package_name
!= NULL
)
7837 struct objfile
*objfile
= cu
->objfile
;
7838 const char *saved_package_name
7839 = obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
7841 strlen (package_name
));
7842 struct type
*type
= init_type (TYPE_CODE_MODULE
, 0, 0,
7843 saved_package_name
, objfile
);
7846 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7848 sym
= allocate_symbol (objfile
);
7849 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
7850 SYMBOL_SET_NAMES (sym
, saved_package_name
,
7851 strlen (saved_package_name
), 0, objfile
);
7852 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7853 e.g., "main" finds the "main" module and not C's main(). */
7854 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7855 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
7856 SYMBOL_TYPE (sym
) = type
;
7858 add_symbol_to_list (sym
, &global_symbols
);
7860 xfree (package_name
);
7864 /* Return the symtab for PER_CU. This works properly regardless of
7865 whether we're using the index or psymtabs. */
7867 static struct compunit_symtab
*
7868 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
7870 return (dwarf2_per_objfile
->using_index
7871 ? per_cu
->v
.quick
->compunit_symtab
7872 : per_cu
->v
.psymtab
->compunit_symtab
);
7875 /* A helper function for computing the list of all symbol tables
7876 included by PER_CU. */
7879 recursively_compute_inclusions (VEC (compunit_symtab_ptr
) **result
,
7880 htab_t all_children
, htab_t all_type_symtabs
,
7881 struct dwarf2_per_cu_data
*per_cu
,
7882 struct compunit_symtab
*immediate_parent
)
7886 struct compunit_symtab
*cust
;
7887 struct dwarf2_per_cu_data
*iter
;
7889 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
7892 /* This inclusion and its children have been processed. */
7897 /* Only add a CU if it has a symbol table. */
7898 cust
= get_compunit_symtab (per_cu
);
7901 /* If this is a type unit only add its symbol table if we haven't
7902 seen it yet (type unit per_cu's can share symtabs). */
7903 if (per_cu
->is_debug_types
)
7905 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
7909 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7910 if (cust
->user
== NULL
)
7911 cust
->user
= immediate_parent
;
7916 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7917 if (cust
->user
== NULL
)
7918 cust
->user
= immediate_parent
;
7923 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
7926 recursively_compute_inclusions (result
, all_children
,
7927 all_type_symtabs
, iter
, cust
);
7931 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
7935 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
7937 gdb_assert (! per_cu
->is_debug_types
);
7939 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
7942 struct dwarf2_per_cu_data
*per_cu_iter
;
7943 struct compunit_symtab
*compunit_symtab_iter
;
7944 VEC (compunit_symtab_ptr
) *result_symtabs
= NULL
;
7945 htab_t all_children
, all_type_symtabs
;
7946 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
7948 /* If we don't have a symtab, we can just skip this case. */
7952 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7953 NULL
, xcalloc
, xfree
);
7954 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7955 NULL
, xcalloc
, xfree
);
7958 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
7962 recursively_compute_inclusions (&result_symtabs
, all_children
,
7963 all_type_symtabs
, per_cu_iter
,
7967 /* Now we have a transitive closure of all the included symtabs. */
7968 len
= VEC_length (compunit_symtab_ptr
, result_symtabs
);
7970 = obstack_alloc (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
7971 (len
+ 1) * sizeof (struct symtab
*));
7973 VEC_iterate (compunit_symtab_ptr
, result_symtabs
, ix
,
7974 compunit_symtab_iter
);
7976 cust
->includes
[ix
] = compunit_symtab_iter
;
7977 cust
->includes
[len
] = NULL
;
7979 VEC_free (compunit_symtab_ptr
, result_symtabs
);
7980 htab_delete (all_children
);
7981 htab_delete (all_type_symtabs
);
7985 /* Compute the 'includes' field for the symtabs of all the CUs we just
7989 process_cu_includes (void)
7992 struct dwarf2_per_cu_data
*iter
;
7995 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
7999 if (! iter
->is_debug_types
)
8000 compute_compunit_symtab_includes (iter
);
8003 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
8006 /* Generate full symbol information for PER_CU, whose DIEs have
8007 already been loaded into memory. */
8010 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
8011 enum language pretend_language
)
8013 struct dwarf2_cu
*cu
= per_cu
->cu
;
8014 struct objfile
*objfile
= per_cu
->objfile
;
8015 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8016 CORE_ADDR lowpc
, highpc
;
8017 struct compunit_symtab
*cust
;
8018 struct cleanup
*back_to
, *delayed_list_cleanup
;
8020 struct block
*static_block
;
8023 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8026 back_to
= make_cleanup (really_free_pendings
, NULL
);
8027 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8029 cu
->list_in_scope
= &file_symbols
;
8031 cu
->language
= pretend_language
;
8032 cu
->language_defn
= language_def (cu
->language
);
8034 /* Do line number decoding in read_file_scope () */
8035 process_die (cu
->dies
, cu
);
8037 /* For now fudge the Go package. */
8038 if (cu
->language
== language_go
)
8039 fixup_go_packaging (cu
);
8041 /* Now that we have processed all the DIEs in the CU, all the types
8042 should be complete, and it should now be safe to compute all of the
8044 compute_delayed_physnames (cu
);
8045 do_cleanups (delayed_list_cleanup
);
8047 /* Some compilers don't define a DW_AT_high_pc attribute for the
8048 compilation unit. If the DW_AT_high_pc is missing, synthesize
8049 it, by scanning the DIE's below the compilation unit. */
8050 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
8052 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
8053 static_block
= end_symtab_get_static_block (addr
, 0, 1);
8055 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
8056 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
8057 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
8058 addrmap to help ensure it has an accurate map of pc values belonging to
8060 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
8062 cust
= end_symtab_from_static_block (static_block
,
8063 SECT_OFF_TEXT (objfile
), 0);
8067 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
8069 /* Set symtab language to language from DW_AT_language. If the
8070 compilation is from a C file generated by language preprocessors, do
8071 not set the language if it was already deduced by start_subfile. */
8072 if (!(cu
->language
== language_c
8073 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
8074 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8076 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
8077 produce DW_AT_location with location lists but it can be possibly
8078 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
8079 there were bugs in prologue debug info, fixed later in GCC-4.5
8080 by "unwind info for epilogues" patch (which is not directly related).
8082 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
8083 needed, it would be wrong due to missing DW_AT_producer there.
8085 Still one can confuse GDB by using non-standard GCC compilation
8086 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
8088 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
8089 cust
->locations_valid
= 1;
8091 if (gcc_4_minor
>= 5)
8092 cust
->epilogue_unwind_valid
= 1;
8094 cust
->call_site_htab
= cu
->call_site_htab
;
8097 if (dwarf2_per_objfile
->using_index
)
8098 per_cu
->v
.quick
->compunit_symtab
= cust
;
8101 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8102 pst
->compunit_symtab
= cust
;
8106 /* Push it for inclusion processing later. */
8107 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
8109 do_cleanups (back_to
);
8112 /* Generate full symbol information for type unit PER_CU, whose DIEs have
8113 already been loaded into memory. */
8116 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
8117 enum language pretend_language
)
8119 struct dwarf2_cu
*cu
= per_cu
->cu
;
8120 struct objfile
*objfile
= per_cu
->objfile
;
8121 struct compunit_symtab
*cust
;
8122 struct cleanup
*back_to
, *delayed_list_cleanup
;
8123 struct signatured_type
*sig_type
;
8125 gdb_assert (per_cu
->is_debug_types
);
8126 sig_type
= (struct signatured_type
*) per_cu
;
8129 back_to
= make_cleanup (really_free_pendings
, NULL
);
8130 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8132 cu
->list_in_scope
= &file_symbols
;
8134 cu
->language
= pretend_language
;
8135 cu
->language_defn
= language_def (cu
->language
);
8137 /* The symbol tables are set up in read_type_unit_scope. */
8138 process_die (cu
->dies
, cu
);
8140 /* For now fudge the Go package. */
8141 if (cu
->language
== language_go
)
8142 fixup_go_packaging (cu
);
8144 /* Now that we have processed all the DIEs in the CU, all the types
8145 should be complete, and it should now be safe to compute all of the
8147 compute_delayed_physnames (cu
);
8148 do_cleanups (delayed_list_cleanup
);
8150 /* TUs share symbol tables.
8151 If this is the first TU to use this symtab, complete the construction
8152 of it with end_expandable_symtab. Otherwise, complete the addition of
8153 this TU's symbols to the existing symtab. */
8154 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
8156 cust
= end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
8157 sig_type
->type_unit_group
->compunit_symtab
= cust
;
8161 /* Set symtab language to language from DW_AT_language. If the
8162 compilation is from a C file generated by language preprocessors,
8163 do not set the language if it was already deduced by
8165 if (!(cu
->language
== language_c
8166 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
8167 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8172 augment_type_symtab ();
8173 cust
= sig_type
->type_unit_group
->compunit_symtab
;
8176 if (dwarf2_per_objfile
->using_index
)
8177 per_cu
->v
.quick
->compunit_symtab
= cust
;
8180 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8181 pst
->compunit_symtab
= cust
;
8185 do_cleanups (back_to
);
8188 /* Process an imported unit DIE. */
8191 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8193 struct attribute
*attr
;
8195 /* For now we don't handle imported units in type units. */
8196 if (cu
->per_cu
->is_debug_types
)
8198 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8199 " supported in type units [in module %s]"),
8200 objfile_name (cu
->objfile
));
8203 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8206 struct dwarf2_per_cu_data
*per_cu
;
8207 struct symtab
*imported_symtab
;
8211 offset
= dwarf2_get_ref_die_offset (attr
);
8212 is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
8213 per_cu
= dwarf2_find_containing_comp_unit (offset
, is_dwz
, cu
->objfile
);
8215 /* If necessary, add it to the queue and load its DIEs. */
8216 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
8217 load_full_comp_unit (per_cu
, cu
->language
);
8219 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8224 /* Reset the in_process bit of a die. */
8227 reset_die_in_process (void *arg
)
8229 struct die_info
*die
= arg
;
8231 die
->in_process
= 0;
8234 /* Process a die and its children. */
8237 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8239 struct cleanup
*in_process
;
8241 /* We should only be processing those not already in process. */
8242 gdb_assert (!die
->in_process
);
8244 die
->in_process
= 1;
8245 in_process
= make_cleanup (reset_die_in_process
,die
);
8249 case DW_TAG_padding
:
8251 case DW_TAG_compile_unit
:
8252 case DW_TAG_partial_unit
:
8253 read_file_scope (die
, cu
);
8255 case DW_TAG_type_unit
:
8256 read_type_unit_scope (die
, cu
);
8258 case DW_TAG_subprogram
:
8259 case DW_TAG_inlined_subroutine
:
8260 read_func_scope (die
, cu
);
8262 case DW_TAG_lexical_block
:
8263 case DW_TAG_try_block
:
8264 case DW_TAG_catch_block
:
8265 read_lexical_block_scope (die
, cu
);
8267 case DW_TAG_GNU_call_site
:
8268 read_call_site_scope (die
, cu
);
8270 case DW_TAG_class_type
:
8271 case DW_TAG_interface_type
:
8272 case DW_TAG_structure_type
:
8273 case DW_TAG_union_type
:
8274 process_structure_scope (die
, cu
);
8276 case DW_TAG_enumeration_type
:
8277 process_enumeration_scope (die
, cu
);
8280 /* These dies have a type, but processing them does not create
8281 a symbol or recurse to process the children. Therefore we can
8282 read them on-demand through read_type_die. */
8283 case DW_TAG_subroutine_type
:
8284 case DW_TAG_set_type
:
8285 case DW_TAG_array_type
:
8286 case DW_TAG_pointer_type
:
8287 case DW_TAG_ptr_to_member_type
:
8288 case DW_TAG_reference_type
:
8289 case DW_TAG_string_type
:
8292 case DW_TAG_base_type
:
8293 case DW_TAG_subrange_type
:
8294 case DW_TAG_typedef
:
8295 /* Add a typedef symbol for the type definition, if it has a
8297 new_symbol (die
, read_type_die (die
, cu
), cu
);
8299 case DW_TAG_common_block
:
8300 read_common_block (die
, cu
);
8302 case DW_TAG_common_inclusion
:
8304 case DW_TAG_namespace
:
8305 cu
->processing_has_namespace_info
= 1;
8306 read_namespace (die
, cu
);
8309 cu
->processing_has_namespace_info
= 1;
8310 read_module (die
, cu
);
8312 case DW_TAG_imported_declaration
:
8313 cu
->processing_has_namespace_info
= 1;
8314 if (read_namespace_alias (die
, cu
))
8316 /* The declaration is not a global namespace alias: fall through. */
8317 case DW_TAG_imported_module
:
8318 cu
->processing_has_namespace_info
= 1;
8319 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
8320 || cu
->language
!= language_fortran
))
8321 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
8322 dwarf_tag_name (die
->tag
));
8323 read_import_statement (die
, cu
);
8326 case DW_TAG_imported_unit
:
8327 process_imported_unit_die (die
, cu
);
8331 new_symbol (die
, NULL
, cu
);
8335 do_cleanups (in_process
);
8338 /* DWARF name computation. */
8340 /* A helper function for dwarf2_compute_name which determines whether DIE
8341 needs to have the name of the scope prepended to the name listed in the
8345 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8347 struct attribute
*attr
;
8351 case DW_TAG_namespace
:
8352 case DW_TAG_typedef
:
8353 case DW_TAG_class_type
:
8354 case DW_TAG_interface_type
:
8355 case DW_TAG_structure_type
:
8356 case DW_TAG_union_type
:
8357 case DW_TAG_enumeration_type
:
8358 case DW_TAG_enumerator
:
8359 case DW_TAG_subprogram
:
8361 case DW_TAG_imported_declaration
:
8364 case DW_TAG_variable
:
8365 case DW_TAG_constant
:
8366 /* We only need to prefix "globally" visible variables. These include
8367 any variable marked with DW_AT_external or any variable that
8368 lives in a namespace. [Variables in anonymous namespaces
8369 require prefixing, but they are not DW_AT_external.] */
8371 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
8373 struct dwarf2_cu
*spec_cu
= cu
;
8375 return die_needs_namespace (die_specification (die
, &spec_cu
),
8379 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
8380 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
8381 && die
->parent
->tag
!= DW_TAG_module
)
8383 /* A variable in a lexical block of some kind does not need a
8384 namespace, even though in C++ such variables may be external
8385 and have a mangled name. */
8386 if (die
->parent
->tag
== DW_TAG_lexical_block
8387 || die
->parent
->tag
== DW_TAG_try_block
8388 || die
->parent
->tag
== DW_TAG_catch_block
8389 || die
->parent
->tag
== DW_TAG_subprogram
)
8398 /* Retrieve the last character from a mem_file. */
8401 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
8403 char *last_char_p
= (char *) object
;
8406 *last_char_p
= buffer
[length
- 1];
8409 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8410 compute the physname for the object, which include a method's:
8411 - formal parameters (C++/Java),
8412 - receiver type (Go),
8413 - return type (Java).
8415 The term "physname" is a bit confusing.
8416 For C++, for example, it is the demangled name.
8417 For Go, for example, it's the mangled name.
8419 For Ada, return the DIE's linkage name rather than the fully qualified
8420 name. PHYSNAME is ignored..
8422 The result is allocated on the objfile_obstack and canonicalized. */
8425 dwarf2_compute_name (const char *name
,
8426 struct die_info
*die
, struct dwarf2_cu
*cu
,
8429 struct objfile
*objfile
= cu
->objfile
;
8432 name
= dwarf2_name (die
, cu
);
8434 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8435 compute it by typename_concat inside GDB. */
8436 if (cu
->language
== language_ada
8437 || (cu
->language
== language_fortran
&& physname
))
8439 /* For Ada unit, we prefer the linkage name over the name, as
8440 the former contains the exported name, which the user expects
8441 to be able to reference. Ideally, we want the user to be able
8442 to reference this entity using either natural or linkage name,
8443 but we haven't started looking at this enhancement yet. */
8444 struct attribute
*attr
;
8446 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8448 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8449 if (attr
&& DW_STRING (attr
))
8450 return DW_STRING (attr
);
8453 /* These are the only languages we know how to qualify names in. */
8455 && (cu
->language
== language_cplus
|| cu
->language
== language_java
8456 || cu
->language
== language_fortran
))
8458 if (die_needs_namespace (die
, cu
))
8462 struct ui_file
*buf
;
8463 char *intermediate_name
;
8464 const char *canonical_name
= NULL
;
8466 prefix
= determine_prefix (die
, cu
);
8467 buf
= mem_fileopen ();
8468 if (*prefix
!= '\0')
8470 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
8473 fputs_unfiltered (prefixed_name
, buf
);
8474 xfree (prefixed_name
);
8477 fputs_unfiltered (name
, buf
);
8479 /* Template parameters may be specified in the DIE's DW_AT_name, or
8480 as children with DW_TAG_template_type_param or
8481 DW_TAG_value_type_param. If the latter, add them to the name
8482 here. If the name already has template parameters, then
8483 skip this step; some versions of GCC emit both, and
8484 it is more efficient to use the pre-computed name.
8486 Something to keep in mind about this process: it is very
8487 unlikely, or in some cases downright impossible, to produce
8488 something that will match the mangled name of a function.
8489 If the definition of the function has the same debug info,
8490 we should be able to match up with it anyway. But fallbacks
8491 using the minimal symbol, for instance to find a method
8492 implemented in a stripped copy of libstdc++, will not work.
8493 If we do not have debug info for the definition, we will have to
8494 match them up some other way.
8496 When we do name matching there is a related problem with function
8497 templates; two instantiated function templates are allowed to
8498 differ only by their return types, which we do not add here. */
8500 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
8502 struct attribute
*attr
;
8503 struct die_info
*child
;
8506 die
->building_fullname
= 1;
8508 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
8512 const gdb_byte
*bytes
;
8513 struct dwarf2_locexpr_baton
*baton
;
8516 if (child
->tag
!= DW_TAG_template_type_param
8517 && child
->tag
!= DW_TAG_template_value_param
)
8522 fputs_unfiltered ("<", buf
);
8526 fputs_unfiltered (", ", buf
);
8528 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
8531 complaint (&symfile_complaints
,
8532 _("template parameter missing DW_AT_type"));
8533 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
8536 type
= die_type (child
, cu
);
8538 if (child
->tag
== DW_TAG_template_type_param
)
8540 c_print_type (type
, "", buf
, -1, 0, &type_print_raw_options
);
8544 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
8547 complaint (&symfile_complaints
,
8548 _("template parameter missing "
8549 "DW_AT_const_value"));
8550 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
8554 dwarf2_const_value_attr (attr
, type
, name
,
8555 &cu
->comp_unit_obstack
, cu
,
8556 &value
, &bytes
, &baton
);
8558 if (TYPE_NOSIGN (type
))
8559 /* GDB prints characters as NUMBER 'CHAR'. If that's
8560 changed, this can use value_print instead. */
8561 c_printchar (value
, type
, buf
);
8564 struct value_print_options opts
;
8567 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
8571 else if (bytes
!= NULL
)
8573 v
= allocate_value (type
);
8574 memcpy (value_contents_writeable (v
), bytes
,
8575 TYPE_LENGTH (type
));
8578 v
= value_from_longest (type
, value
);
8580 /* Specify decimal so that we do not depend on
8582 get_formatted_print_options (&opts
, 'd');
8584 value_print (v
, buf
, &opts
);
8590 die
->building_fullname
= 0;
8594 /* Close the argument list, with a space if necessary
8595 (nested templates). */
8596 char last_char
= '\0';
8597 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
8598 if (last_char
== '>')
8599 fputs_unfiltered (" >", buf
);
8601 fputs_unfiltered (">", buf
);
8605 /* For Java and C++ methods, append formal parameter type
8606 information, if PHYSNAME. */
8608 if (physname
&& die
->tag
== DW_TAG_subprogram
8609 && (cu
->language
== language_cplus
8610 || cu
->language
== language_java
))
8612 struct type
*type
= read_type_die (die
, cu
);
8614 c_type_print_args (type
, buf
, 1, cu
->language
,
8615 &type_print_raw_options
);
8617 if (cu
->language
== language_java
)
8619 /* For java, we must append the return type to method
8621 if (die
->tag
== DW_TAG_subprogram
)
8622 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
8623 0, 0, &type_print_raw_options
);
8625 else if (cu
->language
== language_cplus
)
8627 /* Assume that an artificial first parameter is
8628 "this", but do not crash if it is not. RealView
8629 marks unnamed (and thus unused) parameters as
8630 artificial; there is no way to differentiate
8632 if (TYPE_NFIELDS (type
) > 0
8633 && TYPE_FIELD_ARTIFICIAL (type
, 0)
8634 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
8635 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
8637 fputs_unfiltered (" const", buf
);
8641 intermediate_name
= ui_file_xstrdup (buf
, &length
);
8642 ui_file_delete (buf
);
8644 if (cu
->language
== language_cplus
)
8646 = dwarf2_canonicalize_name (intermediate_name
, cu
,
8647 &objfile
->per_bfd
->storage_obstack
);
8649 /* If we only computed INTERMEDIATE_NAME, or if
8650 INTERMEDIATE_NAME is already canonical, then we need to
8651 copy it to the appropriate obstack. */
8652 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
)
8653 name
= obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8655 strlen (intermediate_name
));
8657 name
= canonical_name
;
8659 xfree (intermediate_name
);
8666 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8667 If scope qualifiers are appropriate they will be added. The result
8668 will be allocated on the storage_obstack, or NULL if the DIE does
8669 not have a name. NAME may either be from a previous call to
8670 dwarf2_name or NULL.
8672 The output string will be canonicalized (if C++/Java). */
8675 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8677 return dwarf2_compute_name (name
, die
, cu
, 0);
8680 /* Construct a physname for the given DIE in CU. NAME may either be
8681 from a previous call to dwarf2_name or NULL. The result will be
8682 allocated on the objfile_objstack or NULL if the DIE does not have a
8685 The output string will be canonicalized (if C++/Java). */
8688 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8690 struct objfile
*objfile
= cu
->objfile
;
8691 struct attribute
*attr
;
8692 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
8693 struct cleanup
*back_to
;
8696 /* In this case dwarf2_compute_name is just a shortcut not building anything
8698 if (!die_needs_namespace (die
, cu
))
8699 return dwarf2_compute_name (name
, die
, cu
, 1);
8701 back_to
= make_cleanup (null_cleanup
, NULL
);
8703 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8705 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8707 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8709 if (attr
&& DW_STRING (attr
))
8713 mangled
= DW_STRING (attr
);
8715 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8716 type. It is easier for GDB users to search for such functions as
8717 `name(params)' than `long name(params)'. In such case the minimal
8718 symbol names do not match the full symbol names but for template
8719 functions there is never a need to look up their definition from their
8720 declaration so the only disadvantage remains the minimal symbol
8721 variant `long name(params)' does not have the proper inferior type.
8724 if (cu
->language
== language_go
)
8726 /* This is a lie, but we already lie to the caller new_symbol_full.
8727 new_symbol_full assumes we return the mangled name.
8728 This just undoes that lie until things are cleaned up. */
8733 demangled
= gdb_demangle (mangled
,
8734 (DMGL_PARAMS
| DMGL_ANSI
8735 | (cu
->language
== language_java
8736 ? DMGL_JAVA
| DMGL_RET_POSTFIX
8741 make_cleanup (xfree
, demangled
);
8751 if (canon
== NULL
|| check_physname
)
8753 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
8755 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
8757 /* It may not mean a bug in GDB. The compiler could also
8758 compute DW_AT_linkage_name incorrectly. But in such case
8759 GDB would need to be bug-to-bug compatible. */
8761 complaint (&symfile_complaints
,
8762 _("Computed physname <%s> does not match demangled <%s> "
8763 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8764 physname
, canon
, mangled
, die
->offset
.sect_off
,
8765 objfile_name (objfile
));
8767 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8768 is available here - over computed PHYSNAME. It is safer
8769 against both buggy GDB and buggy compilers. */
8783 retval
= obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8784 retval
, strlen (retval
));
8786 do_cleanups (back_to
);
8790 /* Inspect DIE in CU for a namespace alias. If one exists, record
8791 a new symbol for it.
8793 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8796 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
8798 struct attribute
*attr
;
8800 /* If the die does not have a name, this is not a namespace
8802 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8806 struct die_info
*d
= die
;
8807 struct dwarf2_cu
*imported_cu
= cu
;
8809 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8810 keep inspecting DIEs until we hit the underlying import. */
8811 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8812 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
8814 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
8818 d
= follow_die_ref (d
, attr
, &imported_cu
);
8819 if (d
->tag
!= DW_TAG_imported_declaration
)
8823 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
8825 complaint (&symfile_complaints
,
8826 _("DIE at 0x%x has too many recursively imported "
8827 "declarations"), d
->offset
.sect_off
);
8834 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
8836 type
= get_die_type_at_offset (offset
, cu
->per_cu
);
8837 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
8839 /* This declaration is a global namespace alias. Add
8840 a symbol for it whose type is the aliased namespace. */
8841 new_symbol (die
, type
, cu
);
8850 /* Read the import statement specified by the given die and record it. */
8853 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
8855 struct objfile
*objfile
= cu
->objfile
;
8856 struct attribute
*import_attr
;
8857 struct die_info
*imported_die
, *child_die
;
8858 struct dwarf2_cu
*imported_cu
;
8859 const char *imported_name
;
8860 const char *imported_name_prefix
;
8861 const char *canonical_name
;
8862 const char *import_alias
;
8863 const char *imported_declaration
= NULL
;
8864 const char *import_prefix
;
8865 VEC (const_char_ptr
) *excludes
= NULL
;
8866 struct cleanup
*cleanups
;
8868 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8869 if (import_attr
== NULL
)
8871 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8872 dwarf_tag_name (die
->tag
));
8877 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
8878 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8879 if (imported_name
== NULL
)
8881 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8883 The import in the following code:
8897 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8898 <52> DW_AT_decl_file : 1
8899 <53> DW_AT_decl_line : 6
8900 <54> DW_AT_import : <0x75>
8901 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8903 <5b> DW_AT_decl_file : 1
8904 <5c> DW_AT_decl_line : 2
8905 <5d> DW_AT_type : <0x6e>
8907 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8908 <76> DW_AT_byte_size : 4
8909 <77> DW_AT_encoding : 5 (signed)
8911 imports the wrong die ( 0x75 instead of 0x58 ).
8912 This case will be ignored until the gcc bug is fixed. */
8916 /* Figure out the local name after import. */
8917 import_alias
= dwarf2_name (die
, cu
);
8919 /* Figure out where the statement is being imported to. */
8920 import_prefix
= determine_prefix (die
, cu
);
8922 /* Figure out what the scope of the imported die is and prepend it
8923 to the name of the imported die. */
8924 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
8926 if (imported_die
->tag
!= DW_TAG_namespace
8927 && imported_die
->tag
!= DW_TAG_module
)
8929 imported_declaration
= imported_name
;
8930 canonical_name
= imported_name_prefix
;
8932 else if (strlen (imported_name_prefix
) > 0)
8933 canonical_name
= obconcat (&objfile
->objfile_obstack
,
8934 imported_name_prefix
, "::", imported_name
,
8937 canonical_name
= imported_name
;
8939 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
8941 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
8942 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
8943 child_die
= sibling_die (child_die
))
8945 /* DWARF-4: A Fortran use statement with a “rename list” may be
8946 represented by an imported module entry with an import attribute
8947 referring to the module and owned entries corresponding to those
8948 entities that are renamed as part of being imported. */
8950 if (child_die
->tag
!= DW_TAG_imported_declaration
)
8952 complaint (&symfile_complaints
,
8953 _("child DW_TAG_imported_declaration expected "
8954 "- DIE at 0x%x [in module %s]"),
8955 child_die
->offset
.sect_off
, objfile_name (objfile
));
8959 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
8960 if (import_attr
== NULL
)
8962 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8963 dwarf_tag_name (child_die
->tag
));
8968 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
8970 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8971 if (imported_name
== NULL
)
8973 complaint (&symfile_complaints
,
8974 _("child DW_TAG_imported_declaration has unknown "
8975 "imported name - DIE at 0x%x [in module %s]"),
8976 child_die
->offset
.sect_off
, objfile_name (objfile
));
8980 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
8982 process_die (child_die
, cu
);
8985 cp_add_using_directive (import_prefix
,
8988 imported_declaration
,
8991 &objfile
->objfile_obstack
);
8993 do_cleanups (cleanups
);
8996 /* Cleanup function for handle_DW_AT_stmt_list. */
8999 free_cu_line_header (void *arg
)
9001 struct dwarf2_cu
*cu
= arg
;
9003 free_line_header (cu
->line_header
);
9004 cu
->line_header
= NULL
;
9007 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
9008 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
9009 this, it was first present in GCC release 4.3.0. */
9012 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
9014 if (!cu
->checked_producer
)
9015 check_producer (cu
);
9017 return cu
->producer_is_gcc_lt_4_3
;
9021 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
9022 const char **name
, const char **comp_dir
)
9024 struct attribute
*attr
;
9029 /* Find the filename. Do not use dwarf2_name here, since the filename
9030 is not a source language identifier. */
9031 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
9034 *name
= DW_STRING (attr
);
9037 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
9039 *comp_dir
= DW_STRING (attr
);
9040 else if (producer_is_gcc_lt_4_3 (cu
) && *name
!= NULL
9041 && IS_ABSOLUTE_PATH (*name
))
9043 char *d
= ldirname (*name
);
9047 make_cleanup (xfree
, d
);
9049 if (*comp_dir
!= NULL
)
9051 /* Irix 6.2 native cc prepends <machine>.: to the compilation
9052 directory, get rid of it. */
9053 char *cp
= strchr (*comp_dir
, ':');
9055 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
9060 *name
= "<unknown>";
9063 /* Handle DW_AT_stmt_list for a compilation unit.
9064 DIE is the DW_TAG_compile_unit die for CU.
9065 COMP_DIR is the compilation directory. LOWPC is passed to
9066 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
9069 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
9070 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
9072 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9073 struct attribute
*attr
;
9074 unsigned int line_offset
;
9075 struct line_header line_header_local
;
9076 hashval_t line_header_local_hash
;
9081 gdb_assert (! cu
->per_cu
->is_debug_types
);
9083 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9087 line_offset
= DW_UNSND (attr
);
9089 /* The line header hash table is only created if needed (it exists to
9090 prevent redundant reading of the line table for partial_units).
9091 If we're given a partial_unit, we'll need it. If we're given a
9092 compile_unit, then use the line header hash table if it's already
9093 created, but don't create one just yet. */
9095 if (dwarf2_per_objfile
->line_header_hash
== NULL
9096 && die
->tag
== DW_TAG_partial_unit
)
9098 dwarf2_per_objfile
->line_header_hash
9099 = htab_create_alloc_ex (127, line_header_hash_voidp
,
9100 line_header_eq_voidp
,
9101 free_line_header_voidp
,
9102 &objfile
->objfile_obstack
,
9103 hashtab_obstack_allocate
,
9104 dummy_obstack_deallocate
);
9107 line_header_local
.offset
.sect_off
= line_offset
;
9108 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
9109 line_header_local_hash
= line_header_hash (&line_header_local
);
9110 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
9112 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9114 line_header_local_hash
, NO_INSERT
);
9116 /* For DW_TAG_compile_unit we need info like symtab::linetable which
9117 is not present in *SLOT (since if there is something in *SLOT then
9118 it will be for a partial_unit). */
9119 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
9121 gdb_assert (*slot
!= NULL
);
9122 cu
->line_header
= *slot
;
9127 /* dwarf_decode_line_header does not yet provide sufficient information.
9128 We always have to call also dwarf_decode_lines for it. */
9129 cu
->line_header
= dwarf_decode_line_header (line_offset
, cu
);
9130 if (cu
->line_header
== NULL
)
9133 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
9137 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9139 line_header_local_hash
, INSERT
);
9140 gdb_assert (slot
!= NULL
);
9142 if (slot
!= NULL
&& *slot
== NULL
)
9144 /* This newly decoded line number information unit will be owned
9145 by line_header_hash hash table. */
9146 *slot
= cu
->line_header
;
9150 /* We cannot free any current entry in (*slot) as that struct line_header
9151 may be already used by multiple CUs. Create only temporary decoded
9152 line_header for this CU - it may happen at most once for each line
9153 number information unit. And if we're not using line_header_hash
9154 then this is what we want as well. */
9155 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
9156 make_cleanup (free_cu_line_header
, cu
);
9158 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
9159 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
9163 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
9166 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9168 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9169 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9170 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
9171 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
9172 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
9173 struct attribute
*attr
;
9174 const char *name
= NULL
;
9175 const char *comp_dir
= NULL
;
9176 struct die_info
*child_die
;
9177 bfd
*abfd
= objfile
->obfd
;
9180 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9182 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
9184 /* If we didn't find a lowpc, set it to highpc to avoid complaints
9185 from finish_block. */
9186 if (lowpc
== ((CORE_ADDR
) -1))
9188 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
9190 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
9192 prepare_one_comp_unit (cu
, die
, cu
->language
);
9194 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
9195 standardised yet. As a workaround for the language detection we fall
9196 back to the DW_AT_producer string. */
9197 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
9198 cu
->language
= language_opencl
;
9200 /* Similar hack for Go. */
9201 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
9202 set_cu_language (DW_LANG_Go
, cu
);
9204 dwarf2_start_symtab (cu
, name
, comp_dir
, lowpc
);
9206 /* Decode line number information if present. We do this before
9207 processing child DIEs, so that the line header table is available
9208 for DW_AT_decl_file. */
9209 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, lowpc
);
9211 /* Process all dies in compilation unit. */
9212 if (die
->child
!= NULL
)
9214 child_die
= die
->child
;
9215 while (child_die
&& child_die
->tag
)
9217 process_die (child_die
, cu
);
9218 child_die
= sibling_die (child_die
);
9222 /* Decode macro information, if present. Dwarf 2 macro information
9223 refers to information in the line number info statement program
9224 header, so we can only read it if we've read the header
9226 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
9227 if (attr
&& cu
->line_header
)
9229 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
9230 complaint (&symfile_complaints
,
9231 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
9233 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
9237 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
9238 if (attr
&& cu
->line_header
)
9240 unsigned int macro_offset
= DW_UNSND (attr
);
9242 dwarf_decode_macros (cu
, macro_offset
, 0);
9246 do_cleanups (back_to
);
9249 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
9250 Create the set of symtabs used by this TU, or if this TU is sharing
9251 symtabs with another TU and the symtabs have already been created
9252 then restore those symtabs in the line header.
9253 We don't need the pc/line-number mapping for type units. */
9256 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
9258 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9259 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
9260 struct type_unit_group
*tu_group
;
9262 struct line_header
*lh
;
9263 struct attribute
*attr
;
9264 unsigned int i
, line_offset
;
9265 struct signatured_type
*sig_type
;
9267 gdb_assert (per_cu
->is_debug_types
);
9268 sig_type
= (struct signatured_type
*) per_cu
;
9270 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9272 /* If we're using .gdb_index (includes -readnow) then
9273 per_cu->type_unit_group may not have been set up yet. */
9274 if (sig_type
->type_unit_group
== NULL
)
9275 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
9276 tu_group
= sig_type
->type_unit_group
;
9278 /* If we've already processed this stmt_list there's no real need to
9279 do it again, we could fake it and just recreate the part we need
9280 (file name,index -> symtab mapping). If data shows this optimization
9281 is useful we can do it then. */
9282 first_time
= tu_group
->compunit_symtab
== NULL
;
9284 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9289 line_offset
= DW_UNSND (attr
);
9290 lh
= dwarf_decode_line_header (line_offset
, cu
);
9295 dwarf2_start_symtab (cu
, "", NULL
, 0);
9298 gdb_assert (tu_group
->symtabs
== NULL
);
9299 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9304 cu
->line_header
= lh
;
9305 make_cleanup (free_cu_line_header
, cu
);
9309 struct compunit_symtab
*cust
= dwarf2_start_symtab (cu
, "", NULL
, 0);
9311 tu_group
->num_symtabs
= lh
->num_file_names
;
9312 tu_group
->symtabs
= XNEWVEC (struct symtab
*, lh
->num_file_names
);
9314 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9316 const char *dir
= NULL
;
9317 struct file_entry
*fe
= &lh
->file_names
[i
];
9320 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9321 dwarf2_start_subfile (fe
->name
, dir
);
9323 if (current_subfile
->symtab
== NULL
)
9325 /* NOTE: start_subfile will recognize when it's been passed
9326 a file it has already seen. So we can't assume there's a
9327 simple mapping from lh->file_names to subfiles, plus
9328 lh->file_names may contain dups. */
9329 current_subfile
->symtab
9330 = allocate_symtab (cust
, current_subfile
->name
);
9333 fe
->symtab
= current_subfile
->symtab
;
9334 tu_group
->symtabs
[i
] = fe
->symtab
;
9339 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9341 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9343 struct file_entry
*fe
= &lh
->file_names
[i
];
9345 fe
->symtab
= tu_group
->symtabs
[i
];
9349 /* The main symtab is allocated last. Type units don't have DW_AT_name
9350 so they don't have a "real" (so to speak) symtab anyway.
9351 There is later code that will assign the main symtab to all symbols
9352 that don't have one. We need to handle the case of a symbol with a
9353 missing symtab (DW_AT_decl_file) anyway. */
9356 /* Process DW_TAG_type_unit.
9357 For TUs we want to skip the first top level sibling if it's not the
9358 actual type being defined by this TU. In this case the first top
9359 level sibling is there to provide context only. */
9362 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9364 struct die_info
*child_die
;
9366 prepare_one_comp_unit (cu
, die
, language_minimal
);
9368 /* Initialize (or reinitialize) the machinery for building symtabs.
9369 We do this before processing child DIEs, so that the line header table
9370 is available for DW_AT_decl_file. */
9371 setup_type_unit_groups (die
, cu
);
9373 if (die
->child
!= NULL
)
9375 child_die
= die
->child
;
9376 while (child_die
&& child_die
->tag
)
9378 process_die (child_die
, cu
);
9379 child_die
= sibling_die (child_die
);
9386 http://gcc.gnu.org/wiki/DebugFission
9387 http://gcc.gnu.org/wiki/DebugFissionDWP
9389 To simplify handling of both DWO files ("object" files with the DWARF info)
9390 and DWP files (a file with the DWOs packaged up into one file), we treat
9391 DWP files as having a collection of virtual DWO files. */
9394 hash_dwo_file (const void *item
)
9396 const struct dwo_file
*dwo_file
= item
;
9399 hash
= htab_hash_string (dwo_file
->dwo_name
);
9400 if (dwo_file
->comp_dir
!= NULL
)
9401 hash
+= htab_hash_string (dwo_file
->comp_dir
);
9406 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
9408 const struct dwo_file
*lhs
= item_lhs
;
9409 const struct dwo_file
*rhs
= item_rhs
;
9411 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
9413 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
9414 return lhs
->comp_dir
== rhs
->comp_dir
;
9415 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
9418 /* Allocate a hash table for DWO files. */
9421 allocate_dwo_file_hash_table (void)
9423 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9425 return htab_create_alloc_ex (41,
9429 &objfile
->objfile_obstack
,
9430 hashtab_obstack_allocate
,
9431 dummy_obstack_deallocate
);
9434 /* Lookup DWO file DWO_NAME. */
9437 lookup_dwo_file_slot (const char *dwo_name
, const char *comp_dir
)
9439 struct dwo_file find_entry
;
9442 if (dwarf2_per_objfile
->dwo_files
== NULL
)
9443 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
9445 memset (&find_entry
, 0, sizeof (find_entry
));
9446 find_entry
.dwo_name
= dwo_name
;
9447 find_entry
.comp_dir
= comp_dir
;
9448 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
9454 hash_dwo_unit (const void *item
)
9456 const struct dwo_unit
*dwo_unit
= item
;
9458 /* This drops the top 32 bits of the id, but is ok for a hash. */
9459 return dwo_unit
->signature
;
9463 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
9465 const struct dwo_unit
*lhs
= item_lhs
;
9466 const struct dwo_unit
*rhs
= item_rhs
;
9468 /* The signature is assumed to be unique within the DWO file.
9469 So while object file CU dwo_id's always have the value zero,
9470 that's OK, assuming each object file DWO file has only one CU,
9471 and that's the rule for now. */
9472 return lhs
->signature
== rhs
->signature
;
9475 /* Allocate a hash table for DWO CUs,TUs.
9476 There is one of these tables for each of CUs,TUs for each DWO file. */
9479 allocate_dwo_unit_table (struct objfile
*objfile
)
9481 /* Start out with a pretty small number.
9482 Generally DWO files contain only one CU and maybe some TUs. */
9483 return htab_create_alloc_ex (3,
9487 &objfile
->objfile_obstack
,
9488 hashtab_obstack_allocate
,
9489 dummy_obstack_deallocate
);
9492 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9494 struct create_dwo_cu_data
9496 struct dwo_file
*dwo_file
;
9497 struct dwo_unit dwo_unit
;
9500 /* die_reader_func for create_dwo_cu. */
9503 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
9504 const gdb_byte
*info_ptr
,
9505 struct die_info
*comp_unit_die
,
9509 struct dwarf2_cu
*cu
= reader
->cu
;
9510 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9511 sect_offset offset
= cu
->per_cu
->offset
;
9512 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
9513 struct create_dwo_cu_data
*data
= datap
;
9514 struct dwo_file
*dwo_file
= data
->dwo_file
;
9515 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
9516 struct attribute
*attr
;
9518 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
9521 complaint (&symfile_complaints
,
9522 _("Dwarf Error: debug entry at offset 0x%x is missing"
9523 " its dwo_id [in module %s]"),
9524 offset
.sect_off
, dwo_file
->dwo_name
);
9528 dwo_unit
->dwo_file
= dwo_file
;
9529 dwo_unit
->signature
= DW_UNSND (attr
);
9530 dwo_unit
->section
= section
;
9531 dwo_unit
->offset
= offset
;
9532 dwo_unit
->length
= cu
->per_cu
->length
;
9534 if (dwarf2_read_debug
)
9535 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id %s\n",
9536 offset
.sect_off
, hex_string (dwo_unit
->signature
));
9539 /* Create the dwo_unit for the lone CU in DWO_FILE.
9540 Note: This function processes DWO files only, not DWP files. */
9542 static struct dwo_unit
*
9543 create_dwo_cu (struct dwo_file
*dwo_file
)
9545 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9546 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
9549 const gdb_byte
*info_ptr
, *end_ptr
;
9550 struct create_dwo_cu_data create_dwo_cu_data
;
9551 struct dwo_unit
*dwo_unit
;
9553 dwarf2_read_section (objfile
, section
);
9554 info_ptr
= section
->buffer
;
9556 if (info_ptr
== NULL
)
9559 /* We can't set abfd until now because the section may be empty or
9560 not present, in which case section->asection will be NULL. */
9561 abfd
= get_section_bfd_owner (section
);
9563 if (dwarf2_read_debug
)
9565 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
9566 get_section_name (section
),
9567 get_section_file_name (section
));
9570 create_dwo_cu_data
.dwo_file
= dwo_file
;
9573 end_ptr
= info_ptr
+ section
->size
;
9574 while (info_ptr
< end_ptr
)
9576 struct dwarf2_per_cu_data per_cu
;
9578 memset (&create_dwo_cu_data
.dwo_unit
, 0,
9579 sizeof (create_dwo_cu_data
.dwo_unit
));
9580 memset (&per_cu
, 0, sizeof (per_cu
));
9581 per_cu
.objfile
= objfile
;
9582 per_cu
.is_debug_types
= 0;
9583 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
9584 per_cu
.section
= section
;
9586 init_cutu_and_read_dies_no_follow (&per_cu
, dwo_file
,
9587 create_dwo_cu_reader
,
9588 &create_dwo_cu_data
);
9590 if (create_dwo_cu_data
.dwo_unit
.dwo_file
!= NULL
)
9592 /* If we've already found one, complain. We only support one
9593 because having more than one requires hacking the dwo_name of
9594 each to match, which is highly unlikely to happen. */
9595 if (dwo_unit
!= NULL
)
9597 complaint (&symfile_complaints
,
9598 _("Multiple CUs in DWO file %s [in module %s]"),
9599 dwo_file
->dwo_name
, objfile_name (objfile
));
9603 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
9604 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
9607 info_ptr
+= per_cu
.length
;
9613 /* DWP file .debug_{cu,tu}_index section format:
9614 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9618 Both index sections have the same format, and serve to map a 64-bit
9619 signature to a set of section numbers. Each section begins with a header,
9620 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9621 indexes, and a pool of 32-bit section numbers. The index sections will be
9622 aligned at 8-byte boundaries in the file.
9624 The index section header consists of:
9626 V, 32 bit version number
9628 N, 32 bit number of compilation units or type units in the index
9629 M, 32 bit number of slots in the hash table
9631 Numbers are recorded using the byte order of the application binary.
9633 The hash table begins at offset 16 in the section, and consists of an array
9634 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9635 order of the application binary). Unused slots in the hash table are 0.
9636 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9638 The parallel table begins immediately after the hash table
9639 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9640 array of 32-bit indexes (using the byte order of the application binary),
9641 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9642 table contains a 32-bit index into the pool of section numbers. For unused
9643 hash table slots, the corresponding entry in the parallel table will be 0.
9645 The pool of section numbers begins immediately following the hash table
9646 (at offset 16 + 12 * M from the beginning of the section). The pool of
9647 section numbers consists of an array of 32-bit words (using the byte order
9648 of the application binary). Each item in the array is indexed starting
9649 from 0. The hash table entry provides the index of the first section
9650 number in the set. Additional section numbers in the set follow, and the
9651 set is terminated by a 0 entry (section number 0 is not used in ELF).
9653 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9654 section must be the first entry in the set, and the .debug_abbrev.dwo must
9655 be the second entry. Other members of the set may follow in any order.
9661 DWP Version 2 combines all the .debug_info, etc. sections into one,
9662 and the entries in the index tables are now offsets into these sections.
9663 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9666 Index Section Contents:
9668 Hash Table of Signatures dwp_hash_table.hash_table
9669 Parallel Table of Indices dwp_hash_table.unit_table
9670 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9671 Table of Section Sizes dwp_hash_table.v2.sizes
9673 The index section header consists of:
9675 V, 32 bit version number
9676 L, 32 bit number of columns in the table of section offsets
9677 N, 32 bit number of compilation units or type units in the index
9678 M, 32 bit number of slots in the hash table
9680 Numbers are recorded using the byte order of the application binary.
9682 The hash table has the same format as version 1.
9683 The parallel table of indices has the same format as version 1,
9684 except that the entries are origin-1 indices into the table of sections
9685 offsets and the table of section sizes.
9687 The table of offsets begins immediately following the parallel table
9688 (at offset 16 + 12 * M from the beginning of the section). The table is
9689 a two-dimensional array of 32-bit words (using the byte order of the
9690 application binary), with L columns and N+1 rows, in row-major order.
9691 Each row in the array is indexed starting from 0. The first row provides
9692 a key to the remaining rows: each column in this row provides an identifier
9693 for a debug section, and the offsets in the same column of subsequent rows
9694 refer to that section. The section identifiers are:
9696 DW_SECT_INFO 1 .debug_info.dwo
9697 DW_SECT_TYPES 2 .debug_types.dwo
9698 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9699 DW_SECT_LINE 4 .debug_line.dwo
9700 DW_SECT_LOC 5 .debug_loc.dwo
9701 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9702 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9703 DW_SECT_MACRO 8 .debug_macro.dwo
9705 The offsets provided by the CU and TU index sections are the base offsets
9706 for the contributions made by each CU or TU to the corresponding section
9707 in the package file. Each CU and TU header contains an abbrev_offset
9708 field, used to find the abbreviations table for that CU or TU within the
9709 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9710 be interpreted as relative to the base offset given in the index section.
9711 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9712 should be interpreted as relative to the base offset for .debug_line.dwo,
9713 and offsets into other debug sections obtained from DWARF attributes should
9714 also be interpreted as relative to the corresponding base offset.
9716 The table of sizes begins immediately following the table of offsets.
9717 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9718 with L columns and N rows, in row-major order. Each row in the array is
9719 indexed starting from 1 (row 0 is shared by the two tables).
9723 Hash table lookup is handled the same in version 1 and 2:
9725 We assume that N and M will not exceed 2^32 - 1.
9726 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9728 Given a 64-bit compilation unit signature or a type signature S, an entry
9729 in the hash table is located as follows:
9731 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9732 the low-order k bits all set to 1.
9734 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9736 3) If the hash table entry at index H matches the signature, use that
9737 entry. If the hash table entry at index H is unused (all zeroes),
9738 terminate the search: the signature is not present in the table.
9740 4) Let H = (H + H') modulo M. Repeat at Step 3.
9742 Because M > N and H' and M are relatively prime, the search is guaranteed
9743 to stop at an unused slot or find the match. */
9745 /* Create a hash table to map DWO IDs to their CU/TU entry in
9746 .debug_{info,types}.dwo in DWP_FILE.
9747 Returns NULL if there isn't one.
9748 Note: This function processes DWP files only, not DWO files. */
9750 static struct dwp_hash_table
*
9751 create_dwp_hash_table (struct dwp_file
*dwp_file
, int is_debug_types
)
9753 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9754 bfd
*dbfd
= dwp_file
->dbfd
;
9755 const gdb_byte
*index_ptr
, *index_end
;
9756 struct dwarf2_section_info
*index
;
9757 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
9758 struct dwp_hash_table
*htab
;
9761 index
= &dwp_file
->sections
.tu_index
;
9763 index
= &dwp_file
->sections
.cu_index
;
9765 if (dwarf2_section_empty_p (index
))
9767 dwarf2_read_section (objfile
, index
);
9769 index_ptr
= index
->buffer
;
9770 index_end
= index_ptr
+ index
->size
;
9772 version
= read_4_bytes (dbfd
, index_ptr
);
9775 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
9779 nr_units
= read_4_bytes (dbfd
, index_ptr
);
9781 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
9784 if (version
!= 1 && version
!= 2)
9786 error (_("Dwarf Error: unsupported DWP file version (%s)"
9788 pulongest (version
), dwp_file
->name
);
9790 if (nr_slots
!= (nr_slots
& -nr_slots
))
9792 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9793 " is not power of 2 [in module %s]"),
9794 pulongest (nr_slots
), dwp_file
->name
);
9797 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
9798 htab
->version
= version
;
9799 htab
->nr_columns
= nr_columns
;
9800 htab
->nr_units
= nr_units
;
9801 htab
->nr_slots
= nr_slots
;
9802 htab
->hash_table
= index_ptr
;
9803 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
9805 /* Exit early if the table is empty. */
9806 if (nr_slots
== 0 || nr_units
== 0
9807 || (version
== 2 && nr_columns
== 0))
9809 /* All must be zero. */
9810 if (nr_slots
!= 0 || nr_units
!= 0
9811 || (version
== 2 && nr_columns
!= 0))
9813 complaint (&symfile_complaints
,
9814 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9815 " all zero [in modules %s]"),
9823 htab
->section_pool
.v1
.indices
=
9824 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9825 /* It's harder to decide whether the section is too small in v1.
9826 V1 is deprecated anyway so we punt. */
9830 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9831 int *ids
= htab
->section_pool
.v2
.section_ids
;
9832 /* Reverse map for error checking. */
9833 int ids_seen
[DW_SECT_MAX
+ 1];
9838 error (_("Dwarf Error: bad DWP hash table, too few columns"
9839 " in section table [in module %s]"),
9842 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
9844 error (_("Dwarf Error: bad DWP hash table, too many columns"
9845 " in section table [in module %s]"),
9848 memset (ids
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9849 memset (ids_seen
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9850 for (i
= 0; i
< nr_columns
; ++i
)
9852 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
9854 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
9856 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9857 " in section table [in module %s]"),
9858 id
, dwp_file
->name
);
9860 if (ids_seen
[id
] != -1)
9862 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9863 " id %d in section table [in module %s]"),
9864 id
, dwp_file
->name
);
9869 /* Must have exactly one info or types section. */
9870 if (((ids_seen
[DW_SECT_INFO
] != -1)
9871 + (ids_seen
[DW_SECT_TYPES
] != -1))
9874 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9875 " DWO info/types section [in module %s]"),
9878 /* Must have an abbrev section. */
9879 if (ids_seen
[DW_SECT_ABBREV
] == -1)
9881 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9882 " section [in module %s]"),
9885 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
9886 htab
->section_pool
.v2
.sizes
=
9887 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
9888 * nr_units
* nr_columns
);
9889 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
9890 * nr_units
* nr_columns
))
9893 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9902 /* Update SECTIONS with the data from SECTP.
9904 This function is like the other "locate" section routines that are
9905 passed to bfd_map_over_sections, but in this context the sections to
9906 read comes from the DWP V1 hash table, not the full ELF section table.
9908 The result is non-zero for success, or zero if an error was found. */
9911 locate_v1_virtual_dwo_sections (asection
*sectp
,
9912 struct virtual_v1_dwo_sections
*sections
)
9914 const struct dwop_section_names
*names
= &dwop_section_names
;
9916 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
9918 /* There can be only one. */
9919 if (sections
->abbrev
.s
.asection
!= NULL
)
9921 sections
->abbrev
.s
.asection
= sectp
;
9922 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
9924 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
9925 || section_is_p (sectp
->name
, &names
->types_dwo
))
9927 /* There can be only one. */
9928 if (sections
->info_or_types
.s
.asection
!= NULL
)
9930 sections
->info_or_types
.s
.asection
= sectp
;
9931 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
9933 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
9935 /* There can be only one. */
9936 if (sections
->line
.s
.asection
!= NULL
)
9938 sections
->line
.s
.asection
= sectp
;
9939 sections
->line
.size
= bfd_get_section_size (sectp
);
9941 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
9943 /* There can be only one. */
9944 if (sections
->loc
.s
.asection
!= NULL
)
9946 sections
->loc
.s
.asection
= sectp
;
9947 sections
->loc
.size
= bfd_get_section_size (sectp
);
9949 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
9951 /* There can be only one. */
9952 if (sections
->macinfo
.s
.asection
!= NULL
)
9954 sections
->macinfo
.s
.asection
= sectp
;
9955 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
9957 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
9959 /* There can be only one. */
9960 if (sections
->macro
.s
.asection
!= NULL
)
9962 sections
->macro
.s
.asection
= sectp
;
9963 sections
->macro
.size
= bfd_get_section_size (sectp
);
9965 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
9967 /* There can be only one. */
9968 if (sections
->str_offsets
.s
.asection
!= NULL
)
9970 sections
->str_offsets
.s
.asection
= sectp
;
9971 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
9975 /* No other kind of section is valid. */
9982 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9983 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9984 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9985 This is for DWP version 1 files. */
9987 static struct dwo_unit
*
9988 create_dwo_unit_in_dwp_v1 (struct dwp_file
*dwp_file
,
9989 uint32_t unit_index
,
9990 const char *comp_dir
,
9991 ULONGEST signature
, int is_debug_types
)
9993 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9994 const struct dwp_hash_table
*dwp_htab
=
9995 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
9996 bfd
*dbfd
= dwp_file
->dbfd
;
9997 const char *kind
= is_debug_types
? "TU" : "CU";
9998 struct dwo_file
*dwo_file
;
9999 struct dwo_unit
*dwo_unit
;
10000 struct virtual_v1_dwo_sections sections
;
10001 void **dwo_file_slot
;
10002 char *virtual_dwo_name
;
10003 struct dwarf2_section_info
*cutu
;
10004 struct cleanup
*cleanups
;
10007 gdb_assert (dwp_file
->version
== 1);
10009 if (dwarf2_read_debug
)
10011 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
10013 pulongest (unit_index
), hex_string (signature
),
10017 /* Fetch the sections of this DWO unit.
10018 Put a limit on the number of sections we look for so that bad data
10019 doesn't cause us to loop forever. */
10021 #define MAX_NR_V1_DWO_SECTIONS \
10022 (1 /* .debug_info or .debug_types */ \
10023 + 1 /* .debug_abbrev */ \
10024 + 1 /* .debug_line */ \
10025 + 1 /* .debug_loc */ \
10026 + 1 /* .debug_str_offsets */ \
10027 + 1 /* .debug_macro or .debug_macinfo */ \
10028 + 1 /* trailing zero */)
10030 memset (§ions
, 0, sizeof (sections
));
10031 cleanups
= make_cleanup (null_cleanup
, 0);
10033 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
10036 uint32_t section_nr
=
10037 read_4_bytes (dbfd
,
10038 dwp_htab
->section_pool
.v1
.indices
10039 + (unit_index
+ i
) * sizeof (uint32_t));
10041 if (section_nr
== 0)
10043 if (section_nr
>= dwp_file
->num_sections
)
10045 error (_("Dwarf Error: bad DWP hash table, section number too large"
10046 " [in module %s]"),
10050 sectp
= dwp_file
->elf_sections
[section_nr
];
10051 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
10053 error (_("Dwarf Error: bad DWP hash table, invalid section found"
10054 " [in module %s]"),
10060 || dwarf2_section_empty_p (§ions
.info_or_types
)
10061 || dwarf2_section_empty_p (§ions
.abbrev
))
10063 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
10064 " [in module %s]"),
10067 if (i
== MAX_NR_V1_DWO_SECTIONS
)
10069 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
10070 " [in module %s]"),
10074 /* It's easier for the rest of the code if we fake a struct dwo_file and
10075 have dwo_unit "live" in that. At least for now.
10077 The DWP file can be made up of a random collection of CUs and TUs.
10078 However, for each CU + set of TUs that came from the same original DWO
10079 file, we can combine them back into a virtual DWO file to save space
10080 (fewer struct dwo_file objects to allocate). Remember that for really
10081 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10084 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
10085 get_section_id (§ions
.abbrev
),
10086 get_section_id (§ions
.line
),
10087 get_section_id (§ions
.loc
),
10088 get_section_id (§ions
.str_offsets
));
10089 make_cleanup (xfree
, virtual_dwo_name
);
10090 /* Can we use an existing virtual DWO file? */
10091 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10092 /* Create one if necessary. */
10093 if (*dwo_file_slot
== NULL
)
10095 if (dwarf2_read_debug
)
10097 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10100 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10101 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
10103 strlen (virtual_dwo_name
));
10104 dwo_file
->comp_dir
= comp_dir
;
10105 dwo_file
->sections
.abbrev
= sections
.abbrev
;
10106 dwo_file
->sections
.line
= sections
.line
;
10107 dwo_file
->sections
.loc
= sections
.loc
;
10108 dwo_file
->sections
.macinfo
= sections
.macinfo
;
10109 dwo_file
->sections
.macro
= sections
.macro
;
10110 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
10111 /* The "str" section is global to the entire DWP file. */
10112 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10113 /* The info or types section is assigned below to dwo_unit,
10114 there's no need to record it in dwo_file.
10115 Also, we can't simply record type sections in dwo_file because
10116 we record a pointer into the vector in dwo_unit. As we collect more
10117 types we'll grow the vector and eventually have to reallocate space
10118 for it, invalidating all copies of pointers into the previous
10120 *dwo_file_slot
= dwo_file
;
10124 if (dwarf2_read_debug
)
10126 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10129 dwo_file
= *dwo_file_slot
;
10131 do_cleanups (cleanups
);
10133 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10134 dwo_unit
->dwo_file
= dwo_file
;
10135 dwo_unit
->signature
= signature
;
10136 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
10137 sizeof (struct dwarf2_section_info
));
10138 *dwo_unit
->section
= sections
.info_or_types
;
10139 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10144 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
10145 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
10146 piece within that section used by a TU/CU, return a virtual section
10147 of just that piece. */
10149 static struct dwarf2_section_info
10150 create_dwp_v2_section (struct dwarf2_section_info
*section
,
10151 bfd_size_type offset
, bfd_size_type size
)
10153 struct dwarf2_section_info result
;
10156 gdb_assert (section
!= NULL
);
10157 gdb_assert (!section
->is_virtual
);
10159 memset (&result
, 0, sizeof (result
));
10160 result
.s
.containing_section
= section
;
10161 result
.is_virtual
= 1;
10166 sectp
= get_section_bfd_section (section
);
10168 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
10169 bounds of the real section. This is a pretty-rare event, so just
10170 flag an error (easier) instead of a warning and trying to cope. */
10172 || offset
+ size
> bfd_get_section_size (sectp
))
10174 bfd
*abfd
= sectp
->owner
;
10176 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
10177 " in section %s [in module %s]"),
10178 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
10179 objfile_name (dwarf2_per_objfile
->objfile
));
10182 result
.virtual_offset
= offset
;
10183 result
.size
= size
;
10187 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10188 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10189 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10190 This is for DWP version 2 files. */
10192 static struct dwo_unit
*
10193 create_dwo_unit_in_dwp_v2 (struct dwp_file
*dwp_file
,
10194 uint32_t unit_index
,
10195 const char *comp_dir
,
10196 ULONGEST signature
, int is_debug_types
)
10198 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10199 const struct dwp_hash_table
*dwp_htab
=
10200 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10201 bfd
*dbfd
= dwp_file
->dbfd
;
10202 const char *kind
= is_debug_types
? "TU" : "CU";
10203 struct dwo_file
*dwo_file
;
10204 struct dwo_unit
*dwo_unit
;
10205 struct virtual_v2_dwo_sections sections
;
10206 void **dwo_file_slot
;
10207 char *virtual_dwo_name
;
10208 struct dwarf2_section_info
*cutu
;
10209 struct cleanup
*cleanups
;
10212 gdb_assert (dwp_file
->version
== 2);
10214 if (dwarf2_read_debug
)
10216 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
10218 pulongest (unit_index
), hex_string (signature
),
10222 /* Fetch the section offsets of this DWO unit. */
10224 memset (§ions
, 0, sizeof (sections
));
10225 cleanups
= make_cleanup (null_cleanup
, 0);
10227 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
10229 uint32_t offset
= read_4_bytes (dbfd
,
10230 dwp_htab
->section_pool
.v2
.offsets
10231 + (((unit_index
- 1) * dwp_htab
->nr_columns
10233 * sizeof (uint32_t)));
10234 uint32_t size
= read_4_bytes (dbfd
,
10235 dwp_htab
->section_pool
.v2
.sizes
10236 + (((unit_index
- 1) * dwp_htab
->nr_columns
10238 * sizeof (uint32_t)));
10240 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
10243 case DW_SECT_TYPES
:
10244 sections
.info_or_types_offset
= offset
;
10245 sections
.info_or_types_size
= size
;
10247 case DW_SECT_ABBREV
:
10248 sections
.abbrev_offset
= offset
;
10249 sections
.abbrev_size
= size
;
10252 sections
.line_offset
= offset
;
10253 sections
.line_size
= size
;
10256 sections
.loc_offset
= offset
;
10257 sections
.loc_size
= size
;
10259 case DW_SECT_STR_OFFSETS
:
10260 sections
.str_offsets_offset
= offset
;
10261 sections
.str_offsets_size
= size
;
10263 case DW_SECT_MACINFO
:
10264 sections
.macinfo_offset
= offset
;
10265 sections
.macinfo_size
= size
;
10267 case DW_SECT_MACRO
:
10268 sections
.macro_offset
= offset
;
10269 sections
.macro_size
= size
;
10274 /* It's easier for the rest of the code if we fake a struct dwo_file and
10275 have dwo_unit "live" in that. At least for now.
10277 The DWP file can be made up of a random collection of CUs and TUs.
10278 However, for each CU + set of TUs that came from the same original DWO
10279 file, we can combine them back into a virtual DWO file to save space
10280 (fewer struct dwo_file objects to allocate). Remember that for really
10281 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10284 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10285 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
10286 (long) (sections
.line_size
? sections
.line_offset
: 0),
10287 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
10288 (long) (sections
.str_offsets_size
10289 ? sections
.str_offsets_offset
: 0));
10290 make_cleanup (xfree
, virtual_dwo_name
);
10291 /* Can we use an existing virtual DWO file? */
10292 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10293 /* Create one if necessary. */
10294 if (*dwo_file_slot
== NULL
)
10296 if (dwarf2_read_debug
)
10298 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10301 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10302 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
10304 strlen (virtual_dwo_name
));
10305 dwo_file
->comp_dir
= comp_dir
;
10306 dwo_file
->sections
.abbrev
=
10307 create_dwp_v2_section (&dwp_file
->sections
.abbrev
,
10308 sections
.abbrev_offset
, sections
.abbrev_size
);
10309 dwo_file
->sections
.line
=
10310 create_dwp_v2_section (&dwp_file
->sections
.line
,
10311 sections
.line_offset
, sections
.line_size
);
10312 dwo_file
->sections
.loc
=
10313 create_dwp_v2_section (&dwp_file
->sections
.loc
,
10314 sections
.loc_offset
, sections
.loc_size
);
10315 dwo_file
->sections
.macinfo
=
10316 create_dwp_v2_section (&dwp_file
->sections
.macinfo
,
10317 sections
.macinfo_offset
, sections
.macinfo_size
);
10318 dwo_file
->sections
.macro
=
10319 create_dwp_v2_section (&dwp_file
->sections
.macro
,
10320 sections
.macro_offset
, sections
.macro_size
);
10321 dwo_file
->sections
.str_offsets
=
10322 create_dwp_v2_section (&dwp_file
->sections
.str_offsets
,
10323 sections
.str_offsets_offset
,
10324 sections
.str_offsets_size
);
10325 /* The "str" section is global to the entire DWP file. */
10326 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10327 /* The info or types section is assigned below to dwo_unit,
10328 there's no need to record it in dwo_file.
10329 Also, we can't simply record type sections in dwo_file because
10330 we record a pointer into the vector in dwo_unit. As we collect more
10331 types we'll grow the vector and eventually have to reallocate space
10332 for it, invalidating all copies of pointers into the previous
10334 *dwo_file_slot
= dwo_file
;
10338 if (dwarf2_read_debug
)
10340 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10343 dwo_file
= *dwo_file_slot
;
10345 do_cleanups (cleanups
);
10347 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10348 dwo_unit
->dwo_file
= dwo_file
;
10349 dwo_unit
->signature
= signature
;
10350 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
10351 sizeof (struct dwarf2_section_info
));
10352 *dwo_unit
->section
= create_dwp_v2_section (is_debug_types
10353 ? &dwp_file
->sections
.types
10354 : &dwp_file
->sections
.info
,
10355 sections
.info_or_types_offset
,
10356 sections
.info_or_types_size
);
10357 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10362 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10363 Returns NULL if the signature isn't found. */
10365 static struct dwo_unit
*
10366 lookup_dwo_unit_in_dwp (struct dwp_file
*dwp_file
, const char *comp_dir
,
10367 ULONGEST signature
, int is_debug_types
)
10369 const struct dwp_hash_table
*dwp_htab
=
10370 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10371 bfd
*dbfd
= dwp_file
->dbfd
;
10372 uint32_t mask
= dwp_htab
->nr_slots
- 1;
10373 uint32_t hash
= signature
& mask
;
10374 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
10377 struct dwo_unit find_dwo_cu
, *dwo_cu
;
10379 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
10380 find_dwo_cu
.signature
= signature
;
10381 slot
= htab_find_slot (is_debug_types
10382 ? dwp_file
->loaded_tus
10383 : dwp_file
->loaded_cus
,
10384 &find_dwo_cu
, INSERT
);
10389 /* Use a for loop so that we don't loop forever on bad debug info. */
10390 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
10392 ULONGEST signature_in_table
;
10394 signature_in_table
=
10395 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
10396 if (signature_in_table
== signature
)
10398 uint32_t unit_index
=
10399 read_4_bytes (dbfd
,
10400 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
10402 if (dwp_file
->version
== 1)
10404 *slot
= create_dwo_unit_in_dwp_v1 (dwp_file
, unit_index
,
10405 comp_dir
, signature
,
10410 *slot
= create_dwo_unit_in_dwp_v2 (dwp_file
, unit_index
,
10411 comp_dir
, signature
,
10416 if (signature_in_table
== 0)
10418 hash
= (hash
+ hash2
) & mask
;
10421 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10422 " [in module %s]"),
10426 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10427 Open the file specified by FILE_NAME and hand it off to BFD for
10428 preliminary analysis. Return a newly initialized bfd *, which
10429 includes a canonicalized copy of FILE_NAME.
10430 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10431 SEARCH_CWD is true if the current directory is to be searched.
10432 It will be searched before debug-file-directory.
10433 If successful, the file is added to the bfd include table of the
10434 objfile's bfd (see gdb_bfd_record_inclusion).
10435 If unable to find/open the file, return NULL.
10436 NOTE: This function is derived from symfile_bfd_open. */
10439 try_open_dwop_file (const char *file_name
, int is_dwp
, int search_cwd
)
10443 char *absolute_name
;
10444 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10445 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10446 to debug_file_directory. */
10448 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
10452 if (*debug_file_directory
!= '\0')
10453 search_path
= concat (".", dirname_separator_string
,
10454 debug_file_directory
, NULL
);
10456 search_path
= xstrdup (".");
10459 search_path
= xstrdup (debug_file_directory
);
10461 flags
= OPF_RETURN_REALPATH
;
10463 flags
|= OPF_SEARCH_IN_PATH
;
10464 desc
= openp (search_path
, flags
, file_name
,
10465 O_RDONLY
| O_BINARY
, &absolute_name
);
10466 xfree (search_path
);
10470 sym_bfd
= gdb_bfd_open (absolute_name
, gnutarget
, desc
);
10471 xfree (absolute_name
);
10472 if (sym_bfd
== NULL
)
10474 bfd_set_cacheable (sym_bfd
, 1);
10476 if (!bfd_check_format (sym_bfd
, bfd_object
))
10478 gdb_bfd_unref (sym_bfd
); /* This also closes desc. */
10482 /* Success. Record the bfd as having been included by the objfile's bfd.
10483 This is important because things like demangled_names_hash lives in the
10484 objfile's per_bfd space and may have references to things like symbol
10485 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10486 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
);
10491 /* Try to open DWO file FILE_NAME.
10492 COMP_DIR is the DW_AT_comp_dir attribute.
10493 The result is the bfd handle of the file.
10494 If there is a problem finding or opening the file, return NULL.
10495 Upon success, the canonicalized path of the file is stored in the bfd,
10496 same as symfile_bfd_open. */
10499 open_dwo_file (const char *file_name
, const char *comp_dir
)
10503 if (IS_ABSOLUTE_PATH (file_name
))
10504 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 0 /*search_cwd*/);
10506 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10508 if (comp_dir
!= NULL
)
10510 char *path_to_try
= concat (comp_dir
, SLASH_STRING
, file_name
, NULL
);
10512 /* NOTE: If comp_dir is a relative path, this will also try the
10513 search path, which seems useful. */
10514 abfd
= try_open_dwop_file (path_to_try
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10515 xfree (path_to_try
);
10520 /* That didn't work, try debug-file-directory, which, despite its name,
10521 is a list of paths. */
10523 if (*debug_file_directory
== '\0')
10526 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10529 /* This function is mapped across the sections and remembers the offset and
10530 size of each of the DWO debugging sections we are interested in. */
10533 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
10535 struct dwo_sections
*dwo_sections
= dwo_sections_ptr
;
10536 const struct dwop_section_names
*names
= &dwop_section_names
;
10538 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10540 dwo_sections
->abbrev
.s
.asection
= sectp
;
10541 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
10543 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10545 dwo_sections
->info
.s
.asection
= sectp
;
10546 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
10548 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10550 dwo_sections
->line
.s
.asection
= sectp
;
10551 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
10553 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10555 dwo_sections
->loc
.s
.asection
= sectp
;
10556 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
10558 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10560 dwo_sections
->macinfo
.s
.asection
= sectp
;
10561 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
10563 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10565 dwo_sections
->macro
.s
.asection
= sectp
;
10566 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
10568 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
10570 dwo_sections
->str
.s
.asection
= sectp
;
10571 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
10573 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10575 dwo_sections
->str_offsets
.s
.asection
= sectp
;
10576 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
10578 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10580 struct dwarf2_section_info type_section
;
10582 memset (&type_section
, 0, sizeof (type_section
));
10583 type_section
.s
.asection
= sectp
;
10584 type_section
.size
= bfd_get_section_size (sectp
);
10585 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
10590 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10591 by PER_CU. This is for the non-DWP case.
10592 The result is NULL if DWO_NAME can't be found. */
10594 static struct dwo_file
*
10595 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
10596 const char *dwo_name
, const char *comp_dir
)
10598 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10599 struct dwo_file
*dwo_file
;
10601 struct cleanup
*cleanups
;
10603 dbfd
= open_dwo_file (dwo_name
, comp_dir
);
10606 if (dwarf2_read_debug
)
10607 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
10610 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10611 dwo_file
->dwo_name
= dwo_name
;
10612 dwo_file
->comp_dir
= comp_dir
;
10613 dwo_file
->dbfd
= dbfd
;
10615 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
10617 bfd_map_over_sections (dbfd
, dwarf2_locate_dwo_sections
, &dwo_file
->sections
);
10619 dwo_file
->cu
= create_dwo_cu (dwo_file
);
10621 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
10622 dwo_file
->sections
.types
);
10624 discard_cleanups (cleanups
);
10626 if (dwarf2_read_debug
)
10627 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
10632 /* This function is mapped across the sections and remembers the offset and
10633 size of each of the DWP debugging sections common to version 1 and 2 that
10634 we are interested in. */
10637 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
10638 void *dwp_file_ptr
)
10640 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10641 const struct dwop_section_names
*names
= &dwop_section_names
;
10642 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10644 /* Record the ELF section number for later lookup: this is what the
10645 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10646 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10647 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10649 /* Look for specific sections that we need. */
10650 if (section_is_p (sectp
->name
, &names
->str_dwo
))
10652 dwp_file
->sections
.str
.s
.asection
= sectp
;
10653 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
10655 else if (section_is_p (sectp
->name
, &names
->cu_index
))
10657 dwp_file
->sections
.cu_index
.s
.asection
= sectp
;
10658 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
10660 else if (section_is_p (sectp
->name
, &names
->tu_index
))
10662 dwp_file
->sections
.tu_index
.s
.asection
= sectp
;
10663 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
10667 /* This function is mapped across the sections and remembers the offset and
10668 size of each of the DWP version 2 debugging sections that we are interested
10669 in. This is split into a separate function because we don't know if we
10670 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10673 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
10675 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10676 const struct dwop_section_names
*names
= &dwop_section_names
;
10677 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10679 /* Record the ELF section number for later lookup: this is what the
10680 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10681 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10682 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10684 /* Look for specific sections that we need. */
10685 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10687 dwp_file
->sections
.abbrev
.s
.asection
= sectp
;
10688 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
10690 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10692 dwp_file
->sections
.info
.s
.asection
= sectp
;
10693 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
10695 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10697 dwp_file
->sections
.line
.s
.asection
= sectp
;
10698 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
10700 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10702 dwp_file
->sections
.loc
.s
.asection
= sectp
;
10703 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
10705 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10707 dwp_file
->sections
.macinfo
.s
.asection
= sectp
;
10708 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
10710 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10712 dwp_file
->sections
.macro
.s
.asection
= sectp
;
10713 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
10715 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10717 dwp_file
->sections
.str_offsets
.s
.asection
= sectp
;
10718 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
10720 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10722 dwp_file
->sections
.types
.s
.asection
= sectp
;
10723 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
10727 /* Hash function for dwp_file loaded CUs/TUs. */
10730 hash_dwp_loaded_cutus (const void *item
)
10732 const struct dwo_unit
*dwo_unit
= item
;
10734 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10735 return dwo_unit
->signature
;
10738 /* Equality function for dwp_file loaded CUs/TUs. */
10741 eq_dwp_loaded_cutus (const void *a
, const void *b
)
10743 const struct dwo_unit
*dua
= a
;
10744 const struct dwo_unit
*dub
= b
;
10746 return dua
->signature
== dub
->signature
;
10749 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10752 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
10754 return htab_create_alloc_ex (3,
10755 hash_dwp_loaded_cutus
,
10756 eq_dwp_loaded_cutus
,
10758 &objfile
->objfile_obstack
,
10759 hashtab_obstack_allocate
,
10760 dummy_obstack_deallocate
);
10763 /* Try to open DWP file FILE_NAME.
10764 The result is the bfd handle of the file.
10765 If there is a problem finding or opening the file, return NULL.
10766 Upon success, the canonicalized path of the file is stored in the bfd,
10767 same as symfile_bfd_open. */
10770 open_dwp_file (const char *file_name
)
10774 abfd
= try_open_dwop_file (file_name
, 1 /*is_dwp*/, 1 /*search_cwd*/);
10778 /* Work around upstream bug 15652.
10779 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10780 [Whether that's a "bug" is debatable, but it is getting in our way.]
10781 We have no real idea where the dwp file is, because gdb's realpath-ing
10782 of the executable's path may have discarded the needed info.
10783 [IWBN if the dwp file name was recorded in the executable, akin to
10784 .gnu_debuglink, but that doesn't exist yet.]
10785 Strip the directory from FILE_NAME and search again. */
10786 if (*debug_file_directory
!= '\0')
10788 /* Don't implicitly search the current directory here.
10789 If the user wants to search "." to handle this case,
10790 it must be added to debug-file-directory. */
10791 return try_open_dwop_file (lbasename (file_name
), 1 /*is_dwp*/,
10798 /* Initialize the use of the DWP file for the current objfile.
10799 By convention the name of the DWP file is ${objfile}.dwp.
10800 The result is NULL if it can't be found. */
10802 static struct dwp_file
*
10803 open_and_init_dwp_file (void)
10805 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10806 struct dwp_file
*dwp_file
;
10809 struct cleanup
*cleanups
;
10811 /* Try to find first .dwp for the binary file before any symbolic links
10813 dwp_name
= xstrprintf ("%s.dwp", objfile
->original_name
);
10814 cleanups
= make_cleanup (xfree
, dwp_name
);
10816 dbfd
= open_dwp_file (dwp_name
);
10818 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
10820 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10821 dwp_name
= xstrprintf ("%s.dwp", objfile_name (objfile
));
10822 make_cleanup (xfree
, dwp_name
);
10823 dbfd
= open_dwp_file (dwp_name
);
10828 if (dwarf2_read_debug
)
10829 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
);
10830 do_cleanups (cleanups
);
10833 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
10834 dwp_file
->name
= bfd_get_filename (dbfd
);
10835 dwp_file
->dbfd
= dbfd
;
10836 do_cleanups (cleanups
);
10838 /* +1: section 0 is unused */
10839 dwp_file
->num_sections
= bfd_count_sections (dbfd
) + 1;
10840 dwp_file
->elf_sections
=
10841 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
10842 dwp_file
->num_sections
, asection
*);
10844 bfd_map_over_sections (dbfd
, dwarf2_locate_common_dwp_sections
, dwp_file
);
10846 dwp_file
->cus
= create_dwp_hash_table (dwp_file
, 0);
10848 dwp_file
->tus
= create_dwp_hash_table (dwp_file
, 1);
10850 /* The DWP file version is stored in the hash table. Oh well. */
10851 if (dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
10853 /* Technically speaking, we should try to limp along, but this is
10854 pretty bizarre. We use pulongest here because that's the established
10855 portability solution (e.g, we cannot use %u for uint32_t). */
10856 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10857 " TU version %s [in DWP file %s]"),
10858 pulongest (dwp_file
->cus
->version
),
10859 pulongest (dwp_file
->tus
->version
), dwp_name
);
10861 dwp_file
->version
= dwp_file
->cus
->version
;
10863 if (dwp_file
->version
== 2)
10864 bfd_map_over_sections (dbfd
, dwarf2_locate_v2_dwp_sections
, dwp_file
);
10866 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
10867 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
10869 if (dwarf2_read_debug
)
10871 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
10872 fprintf_unfiltered (gdb_stdlog
,
10873 " %s CUs, %s TUs\n",
10874 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
10875 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
10881 /* Wrapper around open_and_init_dwp_file, only open it once. */
10883 static struct dwp_file
*
10884 get_dwp_file (void)
10886 if (! dwarf2_per_objfile
->dwp_checked
)
10888 dwarf2_per_objfile
->dwp_file
= open_and_init_dwp_file ();
10889 dwarf2_per_objfile
->dwp_checked
= 1;
10891 return dwarf2_per_objfile
->dwp_file
;
10894 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10895 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10896 or in the DWP file for the objfile, referenced by THIS_UNIT.
10897 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10898 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10900 This is called, for example, when wanting to read a variable with a
10901 complex location. Therefore we don't want to do file i/o for every call.
10902 Therefore we don't want to look for a DWO file on every call.
10903 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10904 then we check if we've already seen DWO_NAME, and only THEN do we check
10907 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10908 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10910 static struct dwo_unit
*
10911 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
10912 const char *dwo_name
, const char *comp_dir
,
10913 ULONGEST signature
, int is_debug_types
)
10915 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10916 const char *kind
= is_debug_types
? "TU" : "CU";
10917 void **dwo_file_slot
;
10918 struct dwo_file
*dwo_file
;
10919 struct dwp_file
*dwp_file
;
10921 /* First see if there's a DWP file.
10922 If we have a DWP file but didn't find the DWO inside it, don't
10923 look for the original DWO file. It makes gdb behave differently
10924 depending on whether one is debugging in the build tree. */
10926 dwp_file
= get_dwp_file ();
10927 if (dwp_file
!= NULL
)
10929 const struct dwp_hash_table
*dwp_htab
=
10930 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10932 if (dwp_htab
!= NULL
)
10934 struct dwo_unit
*dwo_cutu
=
10935 lookup_dwo_unit_in_dwp (dwp_file
, comp_dir
,
10936 signature
, is_debug_types
);
10938 if (dwo_cutu
!= NULL
)
10940 if (dwarf2_read_debug
)
10942 fprintf_unfiltered (gdb_stdlog
,
10943 "Virtual DWO %s %s found: @%s\n",
10944 kind
, hex_string (signature
),
10945 host_address_to_string (dwo_cutu
));
10953 /* No DWP file, look for the DWO file. */
10955 dwo_file_slot
= lookup_dwo_file_slot (dwo_name
, comp_dir
);
10956 if (*dwo_file_slot
== NULL
)
10958 /* Read in the file and build a table of the CUs/TUs it contains. */
10959 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
10961 /* NOTE: This will be NULL if unable to open the file. */
10962 dwo_file
= *dwo_file_slot
;
10964 if (dwo_file
!= NULL
)
10966 struct dwo_unit
*dwo_cutu
= NULL
;
10968 if (is_debug_types
&& dwo_file
->tus
)
10970 struct dwo_unit find_dwo_cutu
;
10972 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
10973 find_dwo_cutu
.signature
= signature
;
10974 dwo_cutu
= htab_find (dwo_file
->tus
, &find_dwo_cutu
);
10976 else if (!is_debug_types
&& dwo_file
->cu
)
10978 if (signature
== dwo_file
->cu
->signature
)
10979 dwo_cutu
= dwo_file
->cu
;
10982 if (dwo_cutu
!= NULL
)
10984 if (dwarf2_read_debug
)
10986 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
10987 kind
, dwo_name
, hex_string (signature
),
10988 host_address_to_string (dwo_cutu
));
10995 /* We didn't find it. This could mean a dwo_id mismatch, or
10996 someone deleted the DWO/DWP file, or the search path isn't set up
10997 correctly to find the file. */
10999 if (dwarf2_read_debug
)
11001 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
11002 kind
, dwo_name
, hex_string (signature
));
11005 /* This is a warning and not a complaint because it can be caused by
11006 pilot error (e.g., user accidentally deleting the DWO). */
11008 /* Print the name of the DWP file if we looked there, helps the user
11009 better diagnose the problem. */
11010 char *dwp_text
= NULL
;
11011 struct cleanup
*cleanups
;
11013 if (dwp_file
!= NULL
)
11014 dwp_text
= xstrprintf (" [in DWP file %s]", lbasename (dwp_file
->name
));
11015 cleanups
= make_cleanup (xfree
, dwp_text
);
11017 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
11018 " [in module %s]"),
11019 kind
, dwo_name
, hex_string (signature
),
11020 dwp_text
!= NULL
? dwp_text
: "",
11021 this_unit
->is_debug_types
? "TU" : "CU",
11022 this_unit
->offset
.sect_off
, objfile_name (objfile
));
11024 do_cleanups (cleanups
);
11029 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
11030 See lookup_dwo_cutu_unit for details. */
11032 static struct dwo_unit
*
11033 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
11034 const char *dwo_name
, const char *comp_dir
,
11035 ULONGEST signature
)
11037 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
11040 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
11041 See lookup_dwo_cutu_unit for details. */
11043 static struct dwo_unit
*
11044 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
11045 const char *dwo_name
, const char *comp_dir
)
11047 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
11050 /* Traversal function for queue_and_load_all_dwo_tus. */
11053 queue_and_load_dwo_tu (void **slot
, void *info
)
11055 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
11056 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
11057 ULONGEST signature
= dwo_unit
->signature
;
11058 struct signatured_type
*sig_type
=
11059 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
11061 if (sig_type
!= NULL
)
11063 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
11065 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
11066 a real dependency of PER_CU on SIG_TYPE. That is detected later
11067 while processing PER_CU. */
11068 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
11069 load_full_type_unit (sig_cu
);
11070 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
11076 /* Queue all TUs contained in the DWO of PER_CU to be read in.
11077 The DWO may have the only definition of the type, though it may not be
11078 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
11079 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
11082 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
11084 struct dwo_unit
*dwo_unit
;
11085 struct dwo_file
*dwo_file
;
11087 gdb_assert (!per_cu
->is_debug_types
);
11088 gdb_assert (get_dwp_file () == NULL
);
11089 gdb_assert (per_cu
->cu
!= NULL
);
11091 dwo_unit
= per_cu
->cu
->dwo_unit
;
11092 gdb_assert (dwo_unit
!= NULL
);
11094 dwo_file
= dwo_unit
->dwo_file
;
11095 if (dwo_file
->tus
!= NULL
)
11096 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
11099 /* Free all resources associated with DWO_FILE.
11100 Close the DWO file and munmap the sections.
11101 All memory should be on the objfile obstack. */
11104 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
11107 struct dwarf2_section_info
*section
;
11109 /* Note: dbfd is NULL for virtual DWO files. */
11110 gdb_bfd_unref (dwo_file
->dbfd
);
11112 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
11115 /* Wrapper for free_dwo_file for use in cleanups. */
11118 free_dwo_file_cleanup (void *arg
)
11120 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
11121 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11123 free_dwo_file (dwo_file
, objfile
);
11126 /* Traversal function for free_dwo_files. */
11129 free_dwo_file_from_slot (void **slot
, void *info
)
11131 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
11132 struct objfile
*objfile
= (struct objfile
*) info
;
11134 free_dwo_file (dwo_file
, objfile
);
11139 /* Free all resources associated with DWO_FILES. */
11142 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
11144 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
11147 /* Read in various DIEs. */
11149 /* qsort helper for inherit_abstract_dies. */
11152 unsigned_int_compar (const void *ap
, const void *bp
)
11154 unsigned int a
= *(unsigned int *) ap
;
11155 unsigned int b
= *(unsigned int *) bp
;
11157 return (a
> b
) - (b
> a
);
11160 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
11161 Inherit only the children of the DW_AT_abstract_origin DIE not being
11162 already referenced by DW_AT_abstract_origin from the children of the
11166 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
11168 struct die_info
*child_die
;
11169 unsigned die_children_count
;
11170 /* CU offsets which were referenced by children of the current DIE. */
11171 sect_offset
*offsets
;
11172 sect_offset
*offsets_end
, *offsetp
;
11173 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
11174 struct die_info
*origin_die
;
11175 /* Iterator of the ORIGIN_DIE children. */
11176 struct die_info
*origin_child_die
;
11177 struct cleanup
*cleanups
;
11178 struct attribute
*attr
;
11179 struct dwarf2_cu
*origin_cu
;
11180 struct pending
**origin_previous_list_in_scope
;
11182 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11186 /* Note that following die references may follow to a die in a
11190 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
11192 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
11194 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
11195 origin_cu
->list_in_scope
= cu
->list_in_scope
;
11197 if (die
->tag
!= origin_die
->tag
11198 && !(die
->tag
== DW_TAG_inlined_subroutine
11199 && origin_die
->tag
== DW_TAG_subprogram
))
11200 complaint (&symfile_complaints
,
11201 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
11202 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
11204 child_die
= die
->child
;
11205 die_children_count
= 0;
11206 while (child_die
&& child_die
->tag
)
11208 child_die
= sibling_die (child_die
);
11209 die_children_count
++;
11211 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
11212 cleanups
= make_cleanup (xfree
, offsets
);
11214 offsets_end
= offsets
;
11215 child_die
= die
->child
;
11216 while (child_die
&& child_die
->tag
)
11218 /* For each CHILD_DIE, find the corresponding child of
11219 ORIGIN_DIE. If there is more than one layer of
11220 DW_AT_abstract_origin, follow them all; there shouldn't be,
11221 but GCC versions at least through 4.4 generate this (GCC PR
11223 struct die_info
*child_origin_die
= child_die
;
11224 struct dwarf2_cu
*child_origin_cu
= cu
;
11228 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
11232 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
11236 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
11237 counterpart may exist. */
11238 if (child_origin_die
!= child_die
)
11240 if (child_die
->tag
!= child_origin_die
->tag
11241 && !(child_die
->tag
== DW_TAG_inlined_subroutine
11242 && child_origin_die
->tag
== DW_TAG_subprogram
))
11243 complaint (&symfile_complaints
,
11244 _("Child DIE 0x%x and its abstract origin 0x%x have "
11245 "different tags"), child_die
->offset
.sect_off
,
11246 child_origin_die
->offset
.sect_off
);
11247 if (child_origin_die
->parent
!= origin_die
)
11248 complaint (&symfile_complaints
,
11249 _("Child DIE 0x%x and its abstract origin 0x%x have "
11250 "different parents"), child_die
->offset
.sect_off
,
11251 child_origin_die
->offset
.sect_off
);
11253 *offsets_end
++ = child_origin_die
->offset
;
11255 child_die
= sibling_die (child_die
);
11257 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
11258 unsigned_int_compar
);
11259 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
11260 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
11261 complaint (&symfile_complaints
,
11262 _("Multiple children of DIE 0x%x refer "
11263 "to DIE 0x%x as their abstract origin"),
11264 die
->offset
.sect_off
, offsetp
->sect_off
);
11267 origin_child_die
= origin_die
->child
;
11268 while (origin_child_die
&& origin_child_die
->tag
)
11270 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11271 while (offsetp
< offsets_end
11272 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
11274 if (offsetp
>= offsets_end
11275 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
11277 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11278 Check whether we're already processing ORIGIN_CHILD_DIE.
11279 This can happen with mutually referenced abstract_origins.
11281 if (!origin_child_die
->in_process
)
11282 process_die (origin_child_die
, origin_cu
);
11284 origin_child_die
= sibling_die (origin_child_die
);
11286 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
11288 do_cleanups (cleanups
);
11292 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11294 struct objfile
*objfile
= cu
->objfile
;
11295 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11296 struct context_stack
*newobj
;
11299 struct die_info
*child_die
;
11300 struct attribute
*attr
, *call_line
, *call_file
;
11302 CORE_ADDR baseaddr
;
11303 struct block
*block
;
11304 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11305 VEC (symbolp
) *template_args
= NULL
;
11306 struct template_symbol
*templ_func
= NULL
;
11310 /* If we do not have call site information, we can't show the
11311 caller of this inlined function. That's too confusing, so
11312 only use the scope for local variables. */
11313 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
11314 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
11315 if (call_line
== NULL
|| call_file
== NULL
)
11317 read_lexical_block_scope (die
, cu
);
11322 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11324 name
= dwarf2_name (die
, cu
);
11326 /* Ignore functions with missing or empty names. These are actually
11327 illegal according to the DWARF standard. */
11330 complaint (&symfile_complaints
,
11331 _("missing name for subprogram DIE at %d"),
11332 die
->offset
.sect_off
);
11336 /* Ignore functions with missing or invalid low and high pc attributes. */
11337 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11339 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
11340 if (!attr
|| !DW_UNSND (attr
))
11341 complaint (&symfile_complaints
,
11342 _("cannot get low and high bounds "
11343 "for subprogram DIE at %d"),
11344 die
->offset
.sect_off
);
11348 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11349 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11351 /* If we have any template arguments, then we must allocate a
11352 different sort of symbol. */
11353 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
11355 if (child_die
->tag
== DW_TAG_template_type_param
11356 || child_die
->tag
== DW_TAG_template_value_param
)
11358 templ_func
= allocate_template_symbol (objfile
);
11359 templ_func
->base
.is_cplus_template_function
= 1;
11364 newobj
= push_context (0, lowpc
);
11365 newobj
->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
11366 (struct symbol
*) templ_func
);
11368 /* If there is a location expression for DW_AT_frame_base, record
11370 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
11372 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
11374 cu
->list_in_scope
= &local_symbols
;
11376 if (die
->child
!= NULL
)
11378 child_die
= die
->child
;
11379 while (child_die
&& child_die
->tag
)
11381 if (child_die
->tag
== DW_TAG_template_type_param
11382 || child_die
->tag
== DW_TAG_template_value_param
)
11384 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
11387 VEC_safe_push (symbolp
, template_args
, arg
);
11390 process_die (child_die
, cu
);
11391 child_die
= sibling_die (child_die
);
11395 inherit_abstract_dies (die
, cu
);
11397 /* If we have a DW_AT_specification, we might need to import using
11398 directives from the context of the specification DIE. See the
11399 comment in determine_prefix. */
11400 if (cu
->language
== language_cplus
11401 && dwarf2_attr (die
, DW_AT_specification
, cu
))
11403 struct dwarf2_cu
*spec_cu
= cu
;
11404 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
11408 child_die
= spec_die
->child
;
11409 while (child_die
&& child_die
->tag
)
11411 if (child_die
->tag
== DW_TAG_imported_module
)
11412 process_die (child_die
, spec_cu
);
11413 child_die
= sibling_die (child_die
);
11416 /* In some cases, GCC generates specification DIEs that
11417 themselves contain DW_AT_specification attributes. */
11418 spec_die
= die_specification (spec_die
, &spec_cu
);
11422 newobj
= pop_context ();
11423 /* Make a block for the local symbols within. */
11424 block
= finish_block (newobj
->name
, &local_symbols
, newobj
->old_blocks
,
11427 /* For C++, set the block's scope. */
11428 if ((cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
11429 && cu
->processing_has_namespace_info
)
11430 block_set_scope (block
, determine_prefix (die
, cu
),
11431 &objfile
->objfile_obstack
);
11433 /* If we have address ranges, record them. */
11434 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11436 gdbarch_make_symbol_special (gdbarch
, newobj
->name
, objfile
);
11438 /* Attach template arguments to function. */
11439 if (! VEC_empty (symbolp
, template_args
))
11441 gdb_assert (templ_func
!= NULL
);
11443 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
11444 templ_func
->template_arguments
11445 = obstack_alloc (&objfile
->objfile_obstack
,
11446 (templ_func
->n_template_arguments
11447 * sizeof (struct symbol
*)));
11448 memcpy (templ_func
->template_arguments
,
11449 VEC_address (symbolp
, template_args
),
11450 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
11451 VEC_free (symbolp
, template_args
);
11454 /* In C++, we can have functions nested inside functions (e.g., when
11455 a function declares a class that has methods). This means that
11456 when we finish processing a function scope, we may need to go
11457 back to building a containing block's symbol lists. */
11458 local_symbols
= newobj
->locals
;
11459 using_directives
= newobj
->using_directives
;
11461 /* If we've finished processing a top-level function, subsequent
11462 symbols go in the file symbol list. */
11463 if (outermost_context_p ())
11464 cu
->list_in_scope
= &file_symbols
;
11467 /* Process all the DIES contained within a lexical block scope. Start
11468 a new scope, process the dies, and then close the scope. */
11471 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11473 struct objfile
*objfile
= cu
->objfile
;
11474 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11475 struct context_stack
*newobj
;
11476 CORE_ADDR lowpc
, highpc
;
11477 struct die_info
*child_die
;
11478 CORE_ADDR baseaddr
;
11480 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11482 /* Ignore blocks with missing or invalid low and high pc attributes. */
11483 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11484 as multiple lexical blocks? Handling children in a sane way would
11485 be nasty. Might be easier to properly extend generic blocks to
11486 describe ranges. */
11487 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11489 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11490 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11492 push_context (0, lowpc
);
11493 if (die
->child
!= NULL
)
11495 child_die
= die
->child
;
11496 while (child_die
&& child_die
->tag
)
11498 process_die (child_die
, cu
);
11499 child_die
= sibling_die (child_die
);
11502 newobj
= pop_context ();
11504 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
11506 struct block
*block
11507 = finish_block (0, &local_symbols
, newobj
->old_blocks
,
11508 newobj
->start_addr
, highpc
);
11510 /* Note that recording ranges after traversing children, as we
11511 do here, means that recording a parent's ranges entails
11512 walking across all its children's ranges as they appear in
11513 the address map, which is quadratic behavior.
11515 It would be nicer to record the parent's ranges before
11516 traversing its children, simply overriding whatever you find
11517 there. But since we don't even decide whether to create a
11518 block until after we've traversed its children, that's hard
11520 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11522 local_symbols
= newobj
->locals
;
11523 using_directives
= newobj
->using_directives
;
11526 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11529 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11531 struct objfile
*objfile
= cu
->objfile
;
11532 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11533 CORE_ADDR pc
, baseaddr
;
11534 struct attribute
*attr
;
11535 struct call_site
*call_site
, call_site_local
;
11538 struct die_info
*child_die
;
11540 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11542 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11545 complaint (&symfile_complaints
,
11546 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11547 "DIE 0x%x [in module %s]"),
11548 die
->offset
.sect_off
, objfile_name (objfile
));
11551 pc
= attr_value_as_address (attr
) + baseaddr
;
11552 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
11554 if (cu
->call_site_htab
== NULL
)
11555 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
11556 NULL
, &objfile
->objfile_obstack
,
11557 hashtab_obstack_allocate
, NULL
);
11558 call_site_local
.pc
= pc
;
11559 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
11562 complaint (&symfile_complaints
,
11563 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11564 "DIE 0x%x [in module %s]"),
11565 paddress (gdbarch
, pc
), die
->offset
.sect_off
,
11566 objfile_name (objfile
));
11570 /* Count parameters at the caller. */
11573 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11574 child_die
= sibling_die (child_die
))
11576 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11578 complaint (&symfile_complaints
,
11579 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11580 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11581 child_die
->tag
, child_die
->offset
.sect_off
,
11582 objfile_name (objfile
));
11589 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
11590 (sizeof (*call_site
)
11591 + (sizeof (*call_site
->parameter
)
11592 * (nparams
- 1))));
11594 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
11595 call_site
->pc
= pc
;
11597 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
11599 struct die_info
*func_die
;
11601 /* Skip also over DW_TAG_inlined_subroutine. */
11602 for (func_die
= die
->parent
;
11603 func_die
&& func_die
->tag
!= DW_TAG_subprogram
11604 && func_die
->tag
!= DW_TAG_subroutine_type
;
11605 func_die
= func_die
->parent
);
11607 /* DW_AT_GNU_all_call_sites is a superset
11608 of DW_AT_GNU_all_tail_call_sites. */
11610 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
11611 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
11613 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11614 not complete. But keep CALL_SITE for look ups via call_site_htab,
11615 both the initial caller containing the real return address PC and
11616 the final callee containing the current PC of a chain of tail
11617 calls do not need to have the tail call list complete. But any
11618 function candidate for a virtual tail call frame searched via
11619 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11620 determined unambiguously. */
11624 struct type
*func_type
= NULL
;
11627 func_type
= get_die_type (func_die
, cu
);
11628 if (func_type
!= NULL
)
11630 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
11632 /* Enlist this call site to the function. */
11633 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
11634 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
11637 complaint (&symfile_complaints
,
11638 _("Cannot find function owning DW_TAG_GNU_call_site "
11639 "DIE 0x%x [in module %s]"),
11640 die
->offset
.sect_off
, objfile_name (objfile
));
11644 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
11646 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11647 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
11648 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
11649 /* Keep NULL DWARF_BLOCK. */;
11650 else if (attr_form_is_block (attr
))
11652 struct dwarf2_locexpr_baton
*dlbaton
;
11654 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
11655 dlbaton
->data
= DW_BLOCK (attr
)->data
;
11656 dlbaton
->size
= DW_BLOCK (attr
)->size
;
11657 dlbaton
->per_cu
= cu
->per_cu
;
11659 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
11661 else if (attr_form_is_ref (attr
))
11663 struct dwarf2_cu
*target_cu
= cu
;
11664 struct die_info
*target_die
;
11666 target_die
= follow_die_ref (die
, attr
, &target_cu
);
11667 gdb_assert (target_cu
->objfile
== objfile
);
11668 if (die_is_declaration (target_die
, target_cu
))
11670 const char *target_physname
= NULL
;
11671 struct attribute
*target_attr
;
11673 /* Prefer the mangled name; otherwise compute the demangled one. */
11674 target_attr
= dwarf2_attr (target_die
, DW_AT_linkage_name
, target_cu
);
11675 if (target_attr
== NULL
)
11676 target_attr
= dwarf2_attr (target_die
, DW_AT_MIPS_linkage_name
,
11678 if (target_attr
!= NULL
&& DW_STRING (target_attr
) != NULL
)
11679 target_physname
= DW_STRING (target_attr
);
11681 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
11682 if (target_physname
== NULL
)
11683 complaint (&symfile_complaints
,
11684 _("DW_AT_GNU_call_site_target target DIE has invalid "
11685 "physname, for referencing DIE 0x%x [in module %s]"),
11686 die
->offset
.sect_off
, objfile_name (objfile
));
11688 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
11694 /* DW_AT_entry_pc should be preferred. */
11695 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
11696 complaint (&symfile_complaints
,
11697 _("DW_AT_GNU_call_site_target target DIE has invalid "
11698 "low pc, for referencing DIE 0x%x [in module %s]"),
11699 die
->offset
.sect_off
, objfile_name (objfile
));
11702 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11703 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
11708 complaint (&symfile_complaints
,
11709 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11710 "block nor reference, for DIE 0x%x [in module %s]"),
11711 die
->offset
.sect_off
, objfile_name (objfile
));
11713 call_site
->per_cu
= cu
->per_cu
;
11715 for (child_die
= die
->child
;
11716 child_die
&& child_die
->tag
;
11717 child_die
= sibling_die (child_die
))
11719 struct call_site_parameter
*parameter
;
11720 struct attribute
*loc
, *origin
;
11722 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11724 /* Already printed the complaint above. */
11728 gdb_assert (call_site
->parameter_count
< nparams
);
11729 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
11731 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11732 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11733 register is contained in DW_AT_GNU_call_site_value. */
11735 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
11736 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
11737 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
11739 sect_offset offset
;
11741 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
11742 offset
= dwarf2_get_ref_die_offset (origin
);
11743 if (!offset_in_cu_p (&cu
->header
, offset
))
11745 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11746 binding can be done only inside one CU. Such referenced DIE
11747 therefore cannot be even moved to DW_TAG_partial_unit. */
11748 complaint (&symfile_complaints
,
11749 _("DW_AT_abstract_origin offset is not in CU for "
11750 "DW_TAG_GNU_call_site child DIE 0x%x "
11752 child_die
->offset
.sect_off
, objfile_name (objfile
));
11755 parameter
->u
.param_offset
.cu_off
= (offset
.sect_off
11756 - cu
->header
.offset
.sect_off
);
11758 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
11760 complaint (&symfile_complaints
,
11761 _("No DW_FORM_block* DW_AT_location for "
11762 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11763 child_die
->offset
.sect_off
, objfile_name (objfile
));
11768 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
11769 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
11770 if (parameter
->u
.dwarf_reg
!= -1)
11771 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
11772 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
11773 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
11774 ¶meter
->u
.fb_offset
))
11775 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
11778 complaint (&symfile_complaints
,
11779 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11780 "for DW_FORM_block* DW_AT_location is supported for "
11781 "DW_TAG_GNU_call_site child DIE 0x%x "
11783 child_die
->offset
.sect_off
, objfile_name (objfile
));
11788 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
11789 if (!attr_form_is_block (attr
))
11791 complaint (&symfile_complaints
,
11792 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11793 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11794 child_die
->offset
.sect_off
, objfile_name (objfile
));
11797 parameter
->value
= DW_BLOCK (attr
)->data
;
11798 parameter
->value_size
= DW_BLOCK (attr
)->size
;
11800 /* Parameters are not pre-cleared by memset above. */
11801 parameter
->data_value
= NULL
;
11802 parameter
->data_value_size
= 0;
11803 call_site
->parameter_count
++;
11805 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
11808 if (!attr_form_is_block (attr
))
11809 complaint (&symfile_complaints
,
11810 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11811 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11812 child_die
->offset
.sect_off
, objfile_name (objfile
));
11815 parameter
->data_value
= DW_BLOCK (attr
)->data
;
11816 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
11822 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11823 Return 1 if the attributes are present and valid, otherwise, return 0.
11824 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11827 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
11828 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
11829 struct partial_symtab
*ranges_pst
)
11831 struct objfile
*objfile
= cu
->objfile
;
11832 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11833 struct comp_unit_head
*cu_header
= &cu
->header
;
11834 bfd
*obfd
= objfile
->obfd
;
11835 unsigned int addr_size
= cu_header
->addr_size
;
11836 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
11837 /* Base address selection entry. */
11840 unsigned int dummy
;
11841 const gdb_byte
*buffer
;
11845 CORE_ADDR high
= 0;
11846 CORE_ADDR baseaddr
;
11848 found_base
= cu
->base_known
;
11849 base
= cu
->base_address
;
11851 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
11852 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
11854 complaint (&symfile_complaints
,
11855 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11859 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
11861 /* Read in the largest possible address. */
11862 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
11863 if ((marker
& mask
) == mask
)
11865 /* If we found the largest possible address, then
11866 read the base address. */
11867 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11868 buffer
+= 2 * addr_size
;
11869 offset
+= 2 * addr_size
;
11875 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11879 CORE_ADDR range_beginning
, range_end
;
11881 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
11882 buffer
+= addr_size
;
11883 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
11884 buffer
+= addr_size
;
11885 offset
+= 2 * addr_size
;
11887 /* An end of list marker is a pair of zero addresses. */
11888 if (range_beginning
== 0 && range_end
== 0)
11889 /* Found the end of list entry. */
11892 /* Each base address selection entry is a pair of 2 values.
11893 The first is the largest possible address, the second is
11894 the base address. Check for a base address here. */
11895 if ((range_beginning
& mask
) == mask
)
11897 /* If we found the largest possible address, then
11898 read the base address. */
11899 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11906 /* We have no valid base address for the ranges
11908 complaint (&symfile_complaints
,
11909 _("Invalid .debug_ranges data (no base address)"));
11913 if (range_beginning
> range_end
)
11915 /* Inverted range entries are invalid. */
11916 complaint (&symfile_complaints
,
11917 _("Invalid .debug_ranges data (inverted range)"));
11921 /* Empty range entries have no effect. */
11922 if (range_beginning
== range_end
)
11925 range_beginning
+= base
;
11928 /* A not-uncommon case of bad debug info.
11929 Don't pollute the addrmap with bad data. */
11930 if (range_beginning
+ baseaddr
== 0
11931 && !dwarf2_per_objfile
->has_section_at_zero
)
11933 complaint (&symfile_complaints
,
11934 _(".debug_ranges entry has start address of zero"
11935 " [in module %s]"), objfile_name (objfile
));
11939 if (ranges_pst
!= NULL
)
11944 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
11945 range_beginning
+ baseaddr
);
11946 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
11947 range_end
+ baseaddr
);
11948 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
11952 /* FIXME: This is recording everything as a low-high
11953 segment of consecutive addresses. We should have a
11954 data structure for discontiguous block ranges
11958 low
= range_beginning
;
11964 if (range_beginning
< low
)
11965 low
= range_beginning
;
11966 if (range_end
> high
)
11972 /* If the first entry is an end-of-list marker, the range
11973 describes an empty scope, i.e. no instructions. */
11979 *high_return
= high
;
11983 /* Get low and high pc attributes from a die. Return 1 if the attributes
11984 are present and valid, otherwise, return 0. Return -1 if the range is
11985 discontinuous, i.e. derived from DW_AT_ranges information. */
11988 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
11989 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
11990 struct partial_symtab
*pst
)
11992 struct attribute
*attr
;
11993 struct attribute
*attr_high
;
11995 CORE_ADDR high
= 0;
11998 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12001 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12004 low
= attr_value_as_address (attr
);
12005 high
= attr_value_as_address (attr_high
);
12006 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12010 /* Found high w/o low attribute. */
12013 /* Found consecutive range of addresses. */
12018 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12021 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12022 We take advantage of the fact that DW_AT_ranges does not appear
12023 in DW_TAG_compile_unit of DWO files. */
12024 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12025 unsigned int ranges_offset
= (DW_UNSND (attr
)
12026 + (need_ranges_base
12030 /* Value of the DW_AT_ranges attribute is the offset in the
12031 .debug_ranges section. */
12032 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
12034 /* Found discontinuous range of addresses. */
12039 /* read_partial_die has also the strict LOW < HIGH requirement. */
12043 /* When using the GNU linker, .gnu.linkonce. sections are used to
12044 eliminate duplicate copies of functions and vtables and such.
12045 The linker will arbitrarily choose one and discard the others.
12046 The AT_*_pc values for such functions refer to local labels in
12047 these sections. If the section from that file was discarded, the
12048 labels are not in the output, so the relocs get a value of 0.
12049 If this is a discarded function, mark the pc bounds as invalid,
12050 so that GDB will ignore it. */
12051 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12060 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
12061 its low and high PC addresses. Do nothing if these addresses could not
12062 be determined. Otherwise, set LOWPC to the low address if it is smaller,
12063 and HIGHPC to the high address if greater than HIGHPC. */
12066 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
12067 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12068 struct dwarf2_cu
*cu
)
12070 CORE_ADDR low
, high
;
12071 struct die_info
*child
= die
->child
;
12073 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
12075 *lowpc
= min (*lowpc
, low
);
12076 *highpc
= max (*highpc
, high
);
12079 /* If the language does not allow nested subprograms (either inside
12080 subprograms or lexical blocks), we're done. */
12081 if (cu
->language
!= language_ada
)
12084 /* Check all the children of the given DIE. If it contains nested
12085 subprograms, then check their pc bounds. Likewise, we need to
12086 check lexical blocks as well, as they may also contain subprogram
12088 while (child
&& child
->tag
)
12090 if (child
->tag
== DW_TAG_subprogram
12091 || child
->tag
== DW_TAG_lexical_block
)
12092 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
12093 child
= sibling_die (child
);
12097 /* Get the low and high pc's represented by the scope DIE, and store
12098 them in *LOWPC and *HIGHPC. If the correct values can't be
12099 determined, set *LOWPC to -1 and *HIGHPC to 0. */
12102 get_scope_pc_bounds (struct die_info
*die
,
12103 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12104 struct dwarf2_cu
*cu
)
12106 CORE_ADDR best_low
= (CORE_ADDR
) -1;
12107 CORE_ADDR best_high
= (CORE_ADDR
) 0;
12108 CORE_ADDR current_low
, current_high
;
12110 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
12112 best_low
= current_low
;
12113 best_high
= current_high
;
12117 struct die_info
*child
= die
->child
;
12119 while (child
&& child
->tag
)
12121 switch (child
->tag
) {
12122 case DW_TAG_subprogram
:
12123 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
12125 case DW_TAG_namespace
:
12126 case DW_TAG_module
:
12127 /* FIXME: carlton/2004-01-16: Should we do this for
12128 DW_TAG_class_type/DW_TAG_structure_type, too? I think
12129 that current GCC's always emit the DIEs corresponding
12130 to definitions of methods of classes as children of a
12131 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
12132 the DIEs giving the declarations, which could be
12133 anywhere). But I don't see any reason why the
12134 standards says that they have to be there. */
12135 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
12137 if (current_low
!= ((CORE_ADDR
) -1))
12139 best_low
= min (best_low
, current_low
);
12140 best_high
= max (best_high
, current_high
);
12148 child
= sibling_die (child
);
12153 *highpc
= best_high
;
12156 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
12160 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
12161 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
12163 struct objfile
*objfile
= cu
->objfile
;
12164 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12165 struct attribute
*attr
;
12166 struct attribute
*attr_high
;
12168 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12171 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12174 CORE_ADDR low
= attr_value_as_address (attr
);
12175 CORE_ADDR high
= attr_value_as_address (attr_high
);
12177 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12180 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
12181 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
12182 record_block_range (block
, low
, high
- 1);
12186 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12189 bfd
*obfd
= objfile
->obfd
;
12190 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12191 We take advantage of the fact that DW_AT_ranges does not appear
12192 in DW_TAG_compile_unit of DWO files. */
12193 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12195 /* The value of the DW_AT_ranges attribute is the offset of the
12196 address range list in the .debug_ranges section. */
12197 unsigned long offset
= (DW_UNSND (attr
)
12198 + (need_ranges_base
? cu
->ranges_base
: 0));
12199 const gdb_byte
*buffer
;
12201 /* For some target architectures, but not others, the
12202 read_address function sign-extends the addresses it returns.
12203 To recognize base address selection entries, we need a
12205 unsigned int addr_size
= cu
->header
.addr_size
;
12206 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
12208 /* The base address, to which the next pair is relative. Note
12209 that this 'base' is a DWARF concept: most entries in a range
12210 list are relative, to reduce the number of relocs against the
12211 debugging information. This is separate from this function's
12212 'baseaddr' argument, which GDB uses to relocate debugging
12213 information from a shared library based on the address at
12214 which the library was loaded. */
12215 CORE_ADDR base
= cu
->base_address
;
12216 int base_known
= cu
->base_known
;
12218 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
12219 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
12221 complaint (&symfile_complaints
,
12222 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
12226 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
12230 unsigned int bytes_read
;
12231 CORE_ADDR start
, end
;
12233 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12234 buffer
+= bytes_read
;
12235 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12236 buffer
+= bytes_read
;
12238 /* Did we find the end of the range list? */
12239 if (start
== 0 && end
== 0)
12242 /* Did we find a base address selection entry? */
12243 else if ((start
& base_select_mask
) == base_select_mask
)
12249 /* We found an ordinary address range. */
12254 complaint (&symfile_complaints
,
12255 _("Invalid .debug_ranges data "
12256 "(no base address)"));
12262 /* Inverted range entries are invalid. */
12263 complaint (&symfile_complaints
,
12264 _("Invalid .debug_ranges data "
12265 "(inverted range)"));
12269 /* Empty range entries have no effect. */
12273 start
+= base
+ baseaddr
;
12274 end
+= base
+ baseaddr
;
12276 /* A not-uncommon case of bad debug info.
12277 Don't pollute the addrmap with bad data. */
12278 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12280 complaint (&symfile_complaints
,
12281 _(".debug_ranges entry has start address of zero"
12282 " [in module %s]"), objfile_name (objfile
));
12286 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
12287 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
12288 record_block_range (block
, start
, end
- 1);
12294 /* Check whether the producer field indicates either of GCC < 4.6, or the
12295 Intel C/C++ compiler, and cache the result in CU. */
12298 check_producer (struct dwarf2_cu
*cu
)
12303 if (cu
->producer
== NULL
)
12305 /* For unknown compilers expect their behavior is DWARF version
12308 GCC started to support .debug_types sections by -gdwarf-4 since
12309 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12310 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12311 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12312 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12314 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
12316 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
12317 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
12319 else if (startswith (cu
->producer
, "Intel(R) C"))
12320 cu
->producer_is_icc
= 1;
12323 /* For other non-GCC compilers, expect their behavior is DWARF version
12327 cu
->checked_producer
= 1;
12330 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12331 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12332 during 4.6.0 experimental. */
12335 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
12337 if (!cu
->checked_producer
)
12338 check_producer (cu
);
12340 return cu
->producer_is_gxx_lt_4_6
;
12343 /* Return the default accessibility type if it is not overriden by
12344 DW_AT_accessibility. */
12346 static enum dwarf_access_attribute
12347 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
12349 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
12351 /* The default DWARF 2 accessibility for members is public, the default
12352 accessibility for inheritance is private. */
12354 if (die
->tag
!= DW_TAG_inheritance
)
12355 return DW_ACCESS_public
;
12357 return DW_ACCESS_private
;
12361 /* DWARF 3+ defines the default accessibility a different way. The same
12362 rules apply now for DW_TAG_inheritance as for the members and it only
12363 depends on the container kind. */
12365 if (die
->parent
->tag
== DW_TAG_class_type
)
12366 return DW_ACCESS_private
;
12368 return DW_ACCESS_public
;
12372 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12373 offset. If the attribute was not found return 0, otherwise return
12374 1. If it was found but could not properly be handled, set *OFFSET
12378 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
12381 struct attribute
*attr
;
12383 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
12388 /* Note that we do not check for a section offset first here.
12389 This is because DW_AT_data_member_location is new in DWARF 4,
12390 so if we see it, we can assume that a constant form is really
12391 a constant and not a section offset. */
12392 if (attr_form_is_constant (attr
))
12393 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
12394 else if (attr_form_is_section_offset (attr
))
12395 dwarf2_complex_location_expr_complaint ();
12396 else if (attr_form_is_block (attr
))
12397 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12399 dwarf2_complex_location_expr_complaint ();
12407 /* Add an aggregate field to the field list. */
12410 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
12411 struct dwarf2_cu
*cu
)
12413 struct objfile
*objfile
= cu
->objfile
;
12414 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12415 struct nextfield
*new_field
;
12416 struct attribute
*attr
;
12418 const char *fieldname
= "";
12420 /* Allocate a new field list entry and link it in. */
12421 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
12422 make_cleanup (xfree
, new_field
);
12423 memset (new_field
, 0, sizeof (struct nextfield
));
12425 if (die
->tag
== DW_TAG_inheritance
)
12427 new_field
->next
= fip
->baseclasses
;
12428 fip
->baseclasses
= new_field
;
12432 new_field
->next
= fip
->fields
;
12433 fip
->fields
= new_field
;
12437 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12439 new_field
->accessibility
= DW_UNSND (attr
);
12441 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
12442 if (new_field
->accessibility
!= DW_ACCESS_public
)
12443 fip
->non_public_fields
= 1;
12445 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12447 new_field
->virtuality
= DW_UNSND (attr
);
12449 new_field
->virtuality
= DW_VIRTUALITY_none
;
12451 fp
= &new_field
->field
;
12453 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
12457 /* Data member other than a C++ static data member. */
12459 /* Get type of field. */
12460 fp
->type
= die_type (die
, cu
);
12462 SET_FIELD_BITPOS (*fp
, 0);
12464 /* Get bit size of field (zero if none). */
12465 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
12468 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
12472 FIELD_BITSIZE (*fp
) = 0;
12475 /* Get bit offset of field. */
12476 if (handle_data_member_location (die
, cu
, &offset
))
12477 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12478 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
12481 if (gdbarch_bits_big_endian (gdbarch
))
12483 /* For big endian bits, the DW_AT_bit_offset gives the
12484 additional bit offset from the MSB of the containing
12485 anonymous object to the MSB of the field. We don't
12486 have to do anything special since we don't need to
12487 know the size of the anonymous object. */
12488 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
12492 /* For little endian bits, compute the bit offset to the
12493 MSB of the anonymous object, subtract off the number of
12494 bits from the MSB of the field to the MSB of the
12495 object, and then subtract off the number of bits of
12496 the field itself. The result is the bit offset of
12497 the LSB of the field. */
12498 int anonymous_size
;
12499 int bit_offset
= DW_UNSND (attr
);
12501 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12504 /* The size of the anonymous object containing
12505 the bit field is explicit, so use the
12506 indicated size (in bytes). */
12507 anonymous_size
= DW_UNSND (attr
);
12511 /* The size of the anonymous object containing
12512 the bit field must be inferred from the type
12513 attribute of the data member containing the
12515 anonymous_size
= TYPE_LENGTH (fp
->type
);
12517 SET_FIELD_BITPOS (*fp
,
12518 (FIELD_BITPOS (*fp
)
12519 + anonymous_size
* bits_per_byte
12520 - bit_offset
- FIELD_BITSIZE (*fp
)));
12524 /* Get name of field. */
12525 fieldname
= dwarf2_name (die
, cu
);
12526 if (fieldname
== NULL
)
12529 /* The name is already allocated along with this objfile, so we don't
12530 need to duplicate it for the type. */
12531 fp
->name
= fieldname
;
12533 /* Change accessibility for artificial fields (e.g. virtual table
12534 pointer or virtual base class pointer) to private. */
12535 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
12537 FIELD_ARTIFICIAL (*fp
) = 1;
12538 new_field
->accessibility
= DW_ACCESS_private
;
12539 fip
->non_public_fields
= 1;
12542 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
12544 /* C++ static member. */
12546 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12547 is a declaration, but all versions of G++ as of this writing
12548 (so through at least 3.2.1) incorrectly generate
12549 DW_TAG_variable tags. */
12551 const char *physname
;
12553 /* Get name of field. */
12554 fieldname
= dwarf2_name (die
, cu
);
12555 if (fieldname
== NULL
)
12558 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
12560 /* Only create a symbol if this is an external value.
12561 new_symbol checks this and puts the value in the global symbol
12562 table, which we want. If it is not external, new_symbol
12563 will try to put the value in cu->list_in_scope which is wrong. */
12564 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
12566 /* A static const member, not much different than an enum as far as
12567 we're concerned, except that we can support more types. */
12568 new_symbol (die
, NULL
, cu
);
12571 /* Get physical name. */
12572 physname
= dwarf2_physname (fieldname
, die
, cu
);
12574 /* The name is already allocated along with this objfile, so we don't
12575 need to duplicate it for the type. */
12576 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
12577 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12578 FIELD_NAME (*fp
) = fieldname
;
12580 else if (die
->tag
== DW_TAG_inheritance
)
12584 /* C++ base class field. */
12585 if (handle_data_member_location (die
, cu
, &offset
))
12586 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12587 FIELD_BITSIZE (*fp
) = 0;
12588 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12589 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
12590 fip
->nbaseclasses
++;
12594 /* Add a typedef defined in the scope of the FIP's class. */
12597 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
12598 struct dwarf2_cu
*cu
)
12600 struct objfile
*objfile
= cu
->objfile
;
12601 struct typedef_field_list
*new_field
;
12602 struct attribute
*attr
;
12603 struct typedef_field
*fp
;
12604 char *fieldname
= "";
12606 /* Allocate a new field list entry and link it in. */
12607 new_field
= xzalloc (sizeof (*new_field
));
12608 make_cleanup (xfree
, new_field
);
12610 gdb_assert (die
->tag
== DW_TAG_typedef
);
12612 fp
= &new_field
->field
;
12614 /* Get name of field. */
12615 fp
->name
= dwarf2_name (die
, cu
);
12616 if (fp
->name
== NULL
)
12619 fp
->type
= read_type_die (die
, cu
);
12621 new_field
->next
= fip
->typedef_field_list
;
12622 fip
->typedef_field_list
= new_field
;
12623 fip
->typedef_field_list_count
++;
12626 /* Create the vector of fields, and attach it to the type. */
12629 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
12630 struct dwarf2_cu
*cu
)
12632 int nfields
= fip
->nfields
;
12634 /* Record the field count, allocate space for the array of fields,
12635 and create blank accessibility bitfields if necessary. */
12636 TYPE_NFIELDS (type
) = nfields
;
12637 TYPE_FIELDS (type
) = (struct field
*)
12638 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
12639 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
12641 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
12643 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12645 TYPE_FIELD_PRIVATE_BITS (type
) =
12646 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12647 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
12649 TYPE_FIELD_PROTECTED_BITS (type
) =
12650 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12651 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
12653 TYPE_FIELD_IGNORE_BITS (type
) =
12654 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12655 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
12658 /* If the type has baseclasses, allocate and clear a bit vector for
12659 TYPE_FIELD_VIRTUAL_BITS. */
12660 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
12662 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
12663 unsigned char *pointer
;
12665 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12666 pointer
= TYPE_ALLOC (type
, num_bytes
);
12667 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
12668 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
12669 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
12672 /* Copy the saved-up fields into the field vector. Start from the head of
12673 the list, adding to the tail of the field array, so that they end up in
12674 the same order in the array in which they were added to the list. */
12675 while (nfields
-- > 0)
12677 struct nextfield
*fieldp
;
12681 fieldp
= fip
->fields
;
12682 fip
->fields
= fieldp
->next
;
12686 fieldp
= fip
->baseclasses
;
12687 fip
->baseclasses
= fieldp
->next
;
12690 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
12691 switch (fieldp
->accessibility
)
12693 case DW_ACCESS_private
:
12694 if (cu
->language
!= language_ada
)
12695 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
12698 case DW_ACCESS_protected
:
12699 if (cu
->language
!= language_ada
)
12700 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
12703 case DW_ACCESS_public
:
12707 /* Unknown accessibility. Complain and treat it as public. */
12709 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
12710 fieldp
->accessibility
);
12714 if (nfields
< fip
->nbaseclasses
)
12716 switch (fieldp
->virtuality
)
12718 case DW_VIRTUALITY_virtual
:
12719 case DW_VIRTUALITY_pure_virtual
:
12720 if (cu
->language
== language_ada
)
12721 error (_("unexpected virtuality in component of Ada type"));
12722 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
12729 /* Return true if this member function is a constructor, false
12733 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
12735 const char *fieldname
;
12736 const char *type_name
;
12739 if (die
->parent
== NULL
)
12742 if (die
->parent
->tag
!= DW_TAG_structure_type
12743 && die
->parent
->tag
!= DW_TAG_union_type
12744 && die
->parent
->tag
!= DW_TAG_class_type
)
12747 fieldname
= dwarf2_name (die
, cu
);
12748 type_name
= dwarf2_name (die
->parent
, cu
);
12749 if (fieldname
== NULL
|| type_name
== NULL
)
12752 len
= strlen (fieldname
);
12753 return (strncmp (fieldname
, type_name
, len
) == 0
12754 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
12757 /* Add a member function to the proper fieldlist. */
12760 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
12761 struct type
*type
, struct dwarf2_cu
*cu
)
12763 struct objfile
*objfile
= cu
->objfile
;
12764 struct attribute
*attr
;
12765 struct fnfieldlist
*flp
;
12767 struct fn_field
*fnp
;
12768 const char *fieldname
;
12769 struct nextfnfield
*new_fnfield
;
12770 struct type
*this_type
;
12771 enum dwarf_access_attribute accessibility
;
12773 if (cu
->language
== language_ada
)
12774 error (_("unexpected member function in Ada type"));
12776 /* Get name of member function. */
12777 fieldname
= dwarf2_name (die
, cu
);
12778 if (fieldname
== NULL
)
12781 /* Look up member function name in fieldlist. */
12782 for (i
= 0; i
< fip
->nfnfields
; i
++)
12784 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
12788 /* Create new list element if necessary. */
12789 if (i
< fip
->nfnfields
)
12790 flp
= &fip
->fnfieldlists
[i
];
12793 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
12795 fip
->fnfieldlists
= (struct fnfieldlist
*)
12796 xrealloc (fip
->fnfieldlists
,
12797 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
12798 * sizeof (struct fnfieldlist
));
12799 if (fip
->nfnfields
== 0)
12800 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
12802 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
12803 flp
->name
= fieldname
;
12806 i
= fip
->nfnfields
++;
12809 /* Create a new member function field and chain it to the field list
12811 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
12812 make_cleanup (xfree
, new_fnfield
);
12813 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
12814 new_fnfield
->next
= flp
->head
;
12815 flp
->head
= new_fnfield
;
12818 /* Fill in the member function field info. */
12819 fnp
= &new_fnfield
->fnfield
;
12821 /* Delay processing of the physname until later. */
12822 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
12824 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
12829 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
12830 fnp
->physname
= physname
? physname
: "";
12833 fnp
->type
= alloc_type (objfile
);
12834 this_type
= read_type_die (die
, cu
);
12835 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
12837 int nparams
= TYPE_NFIELDS (this_type
);
12839 /* TYPE is the domain of this method, and THIS_TYPE is the type
12840 of the method itself (TYPE_CODE_METHOD). */
12841 smash_to_method_type (fnp
->type
, type
,
12842 TYPE_TARGET_TYPE (this_type
),
12843 TYPE_FIELDS (this_type
),
12844 TYPE_NFIELDS (this_type
),
12845 TYPE_VARARGS (this_type
));
12847 /* Handle static member functions.
12848 Dwarf2 has no clean way to discern C++ static and non-static
12849 member functions. G++ helps GDB by marking the first
12850 parameter for non-static member functions (which is the this
12851 pointer) as artificial. We obtain this information from
12852 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12853 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
12854 fnp
->voffset
= VOFFSET_STATIC
;
12857 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
12858 dwarf2_full_name (fieldname
, die
, cu
));
12860 /* Get fcontext from DW_AT_containing_type if present. */
12861 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
12862 fnp
->fcontext
= die_containing_type (die
, cu
);
12864 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12865 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12867 /* Get accessibility. */
12868 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12870 accessibility
= DW_UNSND (attr
);
12872 accessibility
= dwarf2_default_access_attribute (die
, cu
);
12873 switch (accessibility
)
12875 case DW_ACCESS_private
:
12876 fnp
->is_private
= 1;
12878 case DW_ACCESS_protected
:
12879 fnp
->is_protected
= 1;
12883 /* Check for artificial methods. */
12884 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
12885 if (attr
&& DW_UNSND (attr
) != 0)
12886 fnp
->is_artificial
= 1;
12888 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
12890 /* Get index in virtual function table if it is a virtual member
12891 function. For older versions of GCC, this is an offset in the
12892 appropriate virtual table, as specified by DW_AT_containing_type.
12893 For everyone else, it is an expression to be evaluated relative
12894 to the object address. */
12896 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
12899 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
12901 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
12903 /* Old-style GCC. */
12904 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
12906 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12907 || (DW_BLOCK (attr
)->size
> 1
12908 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
12909 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
12911 struct dwarf_block blk
;
12914 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12916 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
12917 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
12918 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12919 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
12920 dwarf2_complex_location_expr_complaint ();
12922 fnp
->voffset
/= cu
->header
.addr_size
;
12926 dwarf2_complex_location_expr_complaint ();
12928 if (!fnp
->fcontext
)
12930 /* If there is no `this' field and no DW_AT_containing_type,
12931 we cannot actually find a base class context for the
12933 if (TYPE_NFIELDS (this_type
) == 0
12934 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
12936 complaint (&symfile_complaints
,
12937 _("cannot determine context for virtual member "
12938 "function \"%s\" (offset %d)"),
12939 fieldname
, die
->offset
.sect_off
);
12944 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
12948 else if (attr_form_is_section_offset (attr
))
12950 dwarf2_complex_location_expr_complaint ();
12954 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12960 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12961 if (attr
&& DW_UNSND (attr
))
12963 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12964 complaint (&symfile_complaints
,
12965 _("Member function \"%s\" (offset %d) is virtual "
12966 "but the vtable offset is not specified"),
12967 fieldname
, die
->offset
.sect_off
);
12968 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12969 TYPE_CPLUS_DYNAMIC (type
) = 1;
12974 /* Create the vector of member function fields, and attach it to the type. */
12977 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
12978 struct dwarf2_cu
*cu
)
12980 struct fnfieldlist
*flp
;
12983 if (cu
->language
== language_ada
)
12984 error (_("unexpected member functions in Ada type"));
12986 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12987 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
12988 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
12990 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
12992 struct nextfnfield
*nfp
= flp
->head
;
12993 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
12996 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
12997 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
12998 fn_flp
->fn_fields
= (struct fn_field
*)
12999 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
13000 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
13001 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
13004 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
13007 /* Returns non-zero if NAME is the name of a vtable member in CU's
13008 language, zero otherwise. */
13010 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
13012 static const char vptr
[] = "_vptr";
13013 static const char vtable
[] = "vtable";
13015 /* Look for the C++ and Java forms of the vtable. */
13016 if ((cu
->language
== language_java
13017 && startswith (name
, vtable
))
13018 || (startswith (name
, vptr
)
13019 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
13025 /* GCC outputs unnamed structures that are really pointers to member
13026 functions, with the ABI-specified layout. If TYPE describes
13027 such a structure, smash it into a member function type.
13029 GCC shouldn't do this; it should just output pointer to member DIEs.
13030 This is GCC PR debug/28767. */
13033 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
13035 struct type
*pfn_type
, *self_type
, *new_type
;
13037 /* Check for a structure with no name and two children. */
13038 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
13041 /* Check for __pfn and __delta members. */
13042 if (TYPE_FIELD_NAME (type
, 0) == NULL
13043 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
13044 || TYPE_FIELD_NAME (type
, 1) == NULL
13045 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
13048 /* Find the type of the method. */
13049 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
13050 if (pfn_type
== NULL
13051 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
13052 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
13055 /* Look for the "this" argument. */
13056 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
13057 if (TYPE_NFIELDS (pfn_type
) == 0
13058 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
13059 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
13062 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
13063 new_type
= alloc_type (objfile
);
13064 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
13065 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
13066 TYPE_VARARGS (pfn_type
));
13067 smash_to_methodptr_type (type
, new_type
);
13070 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
13074 producer_is_icc (struct dwarf2_cu
*cu
)
13076 if (!cu
->checked_producer
)
13077 check_producer (cu
);
13079 return cu
->producer_is_icc
;
13082 /* Called when we find the DIE that starts a structure or union scope
13083 (definition) to create a type for the structure or union. Fill in
13084 the type's name and general properties; the members will not be
13085 processed until process_structure_scope. A symbol table entry for
13086 the type will also not be done until process_structure_scope (assuming
13087 the type has a name).
13089 NOTE: we need to call these functions regardless of whether or not the
13090 DIE has a DW_AT_name attribute, since it might be an anonymous
13091 structure or union. This gets the type entered into our set of
13092 user defined types. */
13094 static struct type
*
13095 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13097 struct objfile
*objfile
= cu
->objfile
;
13099 struct attribute
*attr
;
13102 /* If the definition of this type lives in .debug_types, read that type.
13103 Don't follow DW_AT_specification though, that will take us back up
13104 the chain and we want to go down. */
13105 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13108 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13110 /* The type's CU may not be the same as CU.
13111 Ensure TYPE is recorded with CU in die_type_hash. */
13112 return set_die_type (die
, type
, cu
);
13115 type
= alloc_type (objfile
);
13116 INIT_CPLUS_SPECIFIC (type
);
13118 name
= dwarf2_name (die
, cu
);
13121 if (cu
->language
== language_cplus
13122 || cu
->language
== language_java
)
13124 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
13126 /* dwarf2_full_name might have already finished building the DIE's
13127 type. If so, there is no need to continue. */
13128 if (get_die_type (die
, cu
) != NULL
)
13129 return get_die_type (die
, cu
);
13131 TYPE_TAG_NAME (type
) = full_name
;
13132 if (die
->tag
== DW_TAG_structure_type
13133 || die
->tag
== DW_TAG_class_type
)
13134 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13138 /* The name is already allocated along with this objfile, so
13139 we don't need to duplicate it for the type. */
13140 TYPE_TAG_NAME (type
) = name
;
13141 if (die
->tag
== DW_TAG_class_type
)
13142 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13146 if (die
->tag
== DW_TAG_structure_type
)
13148 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13150 else if (die
->tag
== DW_TAG_union_type
)
13152 TYPE_CODE (type
) = TYPE_CODE_UNION
;
13156 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13159 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
13160 TYPE_DECLARED_CLASS (type
) = 1;
13162 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13165 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13169 TYPE_LENGTH (type
) = 0;
13172 if (producer_is_icc (cu
) && (TYPE_LENGTH (type
) == 0))
13174 /* ICC does not output the required DW_AT_declaration
13175 on incomplete types, but gives them a size of zero. */
13176 TYPE_STUB (type
) = 1;
13179 TYPE_STUB_SUPPORTED (type
) = 1;
13181 if (die_is_declaration (die
, cu
))
13182 TYPE_STUB (type
) = 1;
13183 else if (attr
== NULL
&& die
->child
== NULL
13184 && producer_is_realview (cu
->producer
))
13185 /* RealView does not output the required DW_AT_declaration
13186 on incomplete types. */
13187 TYPE_STUB (type
) = 1;
13189 /* We need to add the type field to the die immediately so we don't
13190 infinitely recurse when dealing with pointers to the structure
13191 type within the structure itself. */
13192 set_die_type (die
, type
, cu
);
13194 /* set_die_type should be already done. */
13195 set_descriptive_type (type
, die
, cu
);
13200 /* Finish creating a structure or union type, including filling in
13201 its members and creating a symbol for it. */
13204 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13206 struct objfile
*objfile
= cu
->objfile
;
13207 struct die_info
*child_die
;
13210 type
= get_die_type (die
, cu
);
13212 type
= read_structure_type (die
, cu
);
13214 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
13216 struct field_info fi
;
13217 VEC (symbolp
) *template_args
= NULL
;
13218 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
13220 memset (&fi
, 0, sizeof (struct field_info
));
13222 child_die
= die
->child
;
13224 while (child_die
&& child_die
->tag
)
13226 if (child_die
->tag
== DW_TAG_member
13227 || child_die
->tag
== DW_TAG_variable
)
13229 /* NOTE: carlton/2002-11-05: A C++ static data member
13230 should be a DW_TAG_member that is a declaration, but
13231 all versions of G++ as of this writing (so through at
13232 least 3.2.1) incorrectly generate DW_TAG_variable
13233 tags for them instead. */
13234 dwarf2_add_field (&fi
, child_die
, cu
);
13236 else if (child_die
->tag
== DW_TAG_subprogram
)
13238 /* C++ member function. */
13239 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
13241 else if (child_die
->tag
== DW_TAG_inheritance
)
13243 /* C++ base class field. */
13244 dwarf2_add_field (&fi
, child_die
, cu
);
13246 else if (child_die
->tag
== DW_TAG_typedef
)
13247 dwarf2_add_typedef (&fi
, child_die
, cu
);
13248 else if (child_die
->tag
== DW_TAG_template_type_param
13249 || child_die
->tag
== DW_TAG_template_value_param
)
13251 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13254 VEC_safe_push (symbolp
, template_args
, arg
);
13257 child_die
= sibling_die (child_die
);
13260 /* Attach template arguments to type. */
13261 if (! VEC_empty (symbolp
, template_args
))
13263 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13264 TYPE_N_TEMPLATE_ARGUMENTS (type
)
13265 = VEC_length (symbolp
, template_args
);
13266 TYPE_TEMPLATE_ARGUMENTS (type
)
13267 = obstack_alloc (&objfile
->objfile_obstack
,
13268 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
13269 * sizeof (struct symbol
*)));
13270 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
13271 VEC_address (symbolp
, template_args
),
13272 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
13273 * sizeof (struct symbol
*)));
13274 VEC_free (symbolp
, template_args
);
13277 /* Attach fields and member functions to the type. */
13279 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
13282 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
13284 /* Get the type which refers to the base class (possibly this
13285 class itself) which contains the vtable pointer for the current
13286 class from the DW_AT_containing_type attribute. This use of
13287 DW_AT_containing_type is a GNU extension. */
13289 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
13291 struct type
*t
= die_containing_type (die
, cu
);
13293 set_type_vptr_basetype (type
, t
);
13298 /* Our own class provides vtbl ptr. */
13299 for (i
= TYPE_NFIELDS (t
) - 1;
13300 i
>= TYPE_N_BASECLASSES (t
);
13303 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
13305 if (is_vtable_name (fieldname
, cu
))
13307 set_type_vptr_fieldno (type
, i
);
13312 /* Complain if virtual function table field not found. */
13313 if (i
< TYPE_N_BASECLASSES (t
))
13314 complaint (&symfile_complaints
,
13315 _("virtual function table pointer "
13316 "not found when defining class '%s'"),
13317 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
13322 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
13325 else if (cu
->producer
13326 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
13328 /* The IBM XLC compiler does not provide direct indication
13329 of the containing type, but the vtable pointer is
13330 always named __vfp. */
13334 for (i
= TYPE_NFIELDS (type
) - 1;
13335 i
>= TYPE_N_BASECLASSES (type
);
13338 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
13340 set_type_vptr_fieldno (type
, i
);
13341 set_type_vptr_basetype (type
, type
);
13348 /* Copy fi.typedef_field_list linked list elements content into the
13349 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13350 if (fi
.typedef_field_list
)
13352 int i
= fi
.typedef_field_list_count
;
13354 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13355 TYPE_TYPEDEF_FIELD_ARRAY (type
)
13356 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
13357 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
13359 /* Reverse the list order to keep the debug info elements order. */
13362 struct typedef_field
*dest
, *src
;
13364 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
13365 src
= &fi
.typedef_field_list
->field
;
13366 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
13371 do_cleanups (back_to
);
13373 if (HAVE_CPLUS_STRUCT (type
))
13374 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
13377 quirk_gcc_member_function_pointer (type
, objfile
);
13379 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13380 snapshots) has been known to create a die giving a declaration
13381 for a class that has, as a child, a die giving a definition for a
13382 nested class. So we have to process our children even if the
13383 current die is a declaration. Normally, of course, a declaration
13384 won't have any children at all. */
13386 child_die
= die
->child
;
13388 while (child_die
!= NULL
&& child_die
->tag
)
13390 if (child_die
->tag
== DW_TAG_member
13391 || child_die
->tag
== DW_TAG_variable
13392 || child_die
->tag
== DW_TAG_inheritance
13393 || child_die
->tag
== DW_TAG_template_value_param
13394 || child_die
->tag
== DW_TAG_template_type_param
)
13399 process_die (child_die
, cu
);
13401 child_die
= sibling_die (child_die
);
13404 /* Do not consider external references. According to the DWARF standard,
13405 these DIEs are identified by the fact that they have no byte_size
13406 attribute, and a declaration attribute. */
13407 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
13408 || !die_is_declaration (die
, cu
))
13409 new_symbol (die
, type
, cu
);
13412 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13413 update TYPE using some information only available in DIE's children. */
13416 update_enumeration_type_from_children (struct die_info
*die
,
13418 struct dwarf2_cu
*cu
)
13420 struct obstack obstack
;
13421 struct die_info
*child_die
;
13422 int unsigned_enum
= 1;
13425 struct cleanup
*old_chain
;
13427 obstack_init (&obstack
);
13428 old_chain
= make_cleanup_obstack_free (&obstack
);
13430 for (child_die
= die
->child
;
13431 child_die
!= NULL
&& child_die
->tag
;
13432 child_die
= sibling_die (child_die
))
13434 struct attribute
*attr
;
13436 const gdb_byte
*bytes
;
13437 struct dwarf2_locexpr_baton
*baton
;
13440 if (child_die
->tag
!= DW_TAG_enumerator
)
13443 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
13447 name
= dwarf2_name (child_die
, cu
);
13449 name
= "<anonymous enumerator>";
13451 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
13452 &value
, &bytes
, &baton
);
13458 else if ((mask
& value
) != 0)
13463 /* If we already know that the enum type is neither unsigned, nor
13464 a flag type, no need to look at the rest of the enumerates. */
13465 if (!unsigned_enum
&& !flag_enum
)
13470 TYPE_UNSIGNED (type
) = 1;
13472 TYPE_FLAG_ENUM (type
) = 1;
13474 do_cleanups (old_chain
);
13477 /* Given a DW_AT_enumeration_type die, set its type. We do not
13478 complete the type's fields yet, or create any symbols. */
13480 static struct type
*
13481 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13483 struct objfile
*objfile
= cu
->objfile
;
13485 struct attribute
*attr
;
13488 /* If the definition of this type lives in .debug_types, read that type.
13489 Don't follow DW_AT_specification though, that will take us back up
13490 the chain and we want to go down. */
13491 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13494 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13496 /* The type's CU may not be the same as CU.
13497 Ensure TYPE is recorded with CU in die_type_hash. */
13498 return set_die_type (die
, type
, cu
);
13501 type
= alloc_type (objfile
);
13503 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
13504 name
= dwarf2_full_name (NULL
, die
, cu
);
13506 TYPE_TAG_NAME (type
) = name
;
13508 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13511 struct type
*underlying_type
= die_type (die
, cu
);
13513 TYPE_TARGET_TYPE (type
) = underlying_type
;
13516 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13519 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13523 TYPE_LENGTH (type
) = 0;
13526 /* The enumeration DIE can be incomplete. In Ada, any type can be
13527 declared as private in the package spec, and then defined only
13528 inside the package body. Such types are known as Taft Amendment
13529 Types. When another package uses such a type, an incomplete DIE
13530 may be generated by the compiler. */
13531 if (die_is_declaration (die
, cu
))
13532 TYPE_STUB (type
) = 1;
13534 /* Finish the creation of this type by using the enum's children.
13535 We must call this even when the underlying type has been provided
13536 so that we can determine if we're looking at a "flag" enum. */
13537 update_enumeration_type_from_children (die
, type
, cu
);
13539 /* If this type has an underlying type that is not a stub, then we
13540 may use its attributes. We always use the "unsigned" attribute
13541 in this situation, because ordinarily we guess whether the type
13542 is unsigned -- but the guess can be wrong and the underlying type
13543 can tell us the reality. However, we defer to a local size
13544 attribute if one exists, because this lets the compiler override
13545 the underlying type if needed. */
13546 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
13548 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
13549 if (TYPE_LENGTH (type
) == 0)
13550 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
13553 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
13555 return set_die_type (die
, type
, cu
);
13558 /* Given a pointer to a die which begins an enumeration, process all
13559 the dies that define the members of the enumeration, and create the
13560 symbol for the enumeration type.
13562 NOTE: We reverse the order of the element list. */
13565 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13567 struct type
*this_type
;
13569 this_type
= get_die_type (die
, cu
);
13570 if (this_type
== NULL
)
13571 this_type
= read_enumeration_type (die
, cu
);
13573 if (die
->child
!= NULL
)
13575 struct die_info
*child_die
;
13576 struct symbol
*sym
;
13577 struct field
*fields
= NULL
;
13578 int num_fields
= 0;
13581 child_die
= die
->child
;
13582 while (child_die
&& child_die
->tag
)
13584 if (child_die
->tag
!= DW_TAG_enumerator
)
13586 process_die (child_die
, cu
);
13590 name
= dwarf2_name (child_die
, cu
);
13593 sym
= new_symbol (child_die
, this_type
, cu
);
13595 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
13597 fields
= (struct field
*)
13599 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
13600 * sizeof (struct field
));
13603 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
13604 FIELD_TYPE (fields
[num_fields
]) = NULL
;
13605 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
13606 FIELD_BITSIZE (fields
[num_fields
]) = 0;
13612 child_die
= sibling_die (child_die
);
13617 TYPE_NFIELDS (this_type
) = num_fields
;
13618 TYPE_FIELDS (this_type
) = (struct field
*)
13619 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
13620 memcpy (TYPE_FIELDS (this_type
), fields
,
13621 sizeof (struct field
) * num_fields
);
13626 /* If we are reading an enum from a .debug_types unit, and the enum
13627 is a declaration, and the enum is not the signatured type in the
13628 unit, then we do not want to add a symbol for it. Adding a
13629 symbol would in some cases obscure the true definition of the
13630 enum, giving users an incomplete type when the definition is
13631 actually available. Note that we do not want to do this for all
13632 enums which are just declarations, because C++0x allows forward
13633 enum declarations. */
13634 if (cu
->per_cu
->is_debug_types
13635 && die_is_declaration (die
, cu
))
13637 struct signatured_type
*sig_type
;
13639 sig_type
= (struct signatured_type
*) cu
->per_cu
;
13640 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
13641 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
13645 new_symbol (die
, this_type
, cu
);
13648 /* Extract all information from a DW_TAG_array_type DIE and put it in
13649 the DIE's type field. For now, this only handles one dimensional
13652 static struct type
*
13653 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13655 struct objfile
*objfile
= cu
->objfile
;
13656 struct die_info
*child_die
;
13658 struct type
*element_type
, *range_type
, *index_type
;
13659 struct type
**range_types
= NULL
;
13660 struct attribute
*attr
;
13662 struct cleanup
*back_to
;
13664 unsigned int bit_stride
= 0;
13666 element_type
= die_type (die
, cu
);
13668 /* The die_type call above may have already set the type for this DIE. */
13669 type
= get_die_type (die
, cu
);
13673 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
13675 bit_stride
= DW_UNSND (attr
) * 8;
13677 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
13679 bit_stride
= DW_UNSND (attr
);
13681 /* Irix 6.2 native cc creates array types without children for
13682 arrays with unspecified length. */
13683 if (die
->child
== NULL
)
13685 index_type
= objfile_type (objfile
)->builtin_int
;
13686 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
13687 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
13689 return set_die_type (die
, type
, cu
);
13692 back_to
= make_cleanup (null_cleanup
, NULL
);
13693 child_die
= die
->child
;
13694 while (child_die
&& child_die
->tag
)
13696 if (child_die
->tag
== DW_TAG_subrange_type
)
13698 struct type
*child_type
= read_type_die (child_die
, cu
);
13700 if (child_type
!= NULL
)
13702 /* The range type was succesfully read. Save it for the
13703 array type creation. */
13704 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
13706 range_types
= (struct type
**)
13707 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
13708 * sizeof (struct type
*));
13710 make_cleanup (free_current_contents
, &range_types
);
13712 range_types
[ndim
++] = child_type
;
13715 child_die
= sibling_die (child_die
);
13718 /* Dwarf2 dimensions are output from left to right, create the
13719 necessary array types in backwards order. */
13721 type
= element_type
;
13723 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
13728 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
13734 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
13738 /* Understand Dwarf2 support for vector types (like they occur on
13739 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13740 array type. This is not part of the Dwarf2/3 standard yet, but a
13741 custom vendor extension. The main difference between a regular
13742 array and the vector variant is that vectors are passed by value
13744 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
13746 make_vector_type (type
);
13748 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13749 implementation may choose to implement triple vectors using this
13751 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13754 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
13755 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13757 complaint (&symfile_complaints
,
13758 _("DW_AT_byte_size for array type smaller "
13759 "than the total size of elements"));
13762 name
= dwarf2_name (die
, cu
);
13764 TYPE_NAME (type
) = name
;
13766 /* Install the type in the die. */
13767 set_die_type (die
, type
, cu
);
13769 /* set_die_type should be already done. */
13770 set_descriptive_type (type
, die
, cu
);
13772 do_cleanups (back_to
);
13777 static enum dwarf_array_dim_ordering
13778 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
13780 struct attribute
*attr
;
13782 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
13784 if (attr
) return DW_SND (attr
);
13786 /* GNU F77 is a special case, as at 08/2004 array type info is the
13787 opposite order to the dwarf2 specification, but data is still
13788 laid out as per normal fortran.
13790 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13791 version checking. */
13793 if (cu
->language
== language_fortran
13794 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
13796 return DW_ORD_row_major
;
13799 switch (cu
->language_defn
->la_array_ordering
)
13801 case array_column_major
:
13802 return DW_ORD_col_major
;
13803 case array_row_major
:
13805 return DW_ORD_row_major
;
13809 /* Extract all information from a DW_TAG_set_type DIE and put it in
13810 the DIE's type field. */
13812 static struct type
*
13813 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13815 struct type
*domain_type
, *set_type
;
13816 struct attribute
*attr
;
13818 domain_type
= die_type (die
, cu
);
13820 /* The die_type call above may have already set the type for this DIE. */
13821 set_type
= get_die_type (die
, cu
);
13825 set_type
= create_set_type (NULL
, domain_type
);
13827 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13829 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
13831 return set_die_type (die
, set_type
, cu
);
13834 /* A helper for read_common_block that creates a locexpr baton.
13835 SYM is the symbol which we are marking as computed.
13836 COMMON_DIE is the DIE for the common block.
13837 COMMON_LOC is the location expression attribute for the common
13839 MEMBER_LOC is the location expression attribute for the particular
13840 member of the common block that we are processing.
13841 CU is the CU from which the above come. */
13844 mark_common_block_symbol_computed (struct symbol
*sym
,
13845 struct die_info
*common_die
,
13846 struct attribute
*common_loc
,
13847 struct attribute
*member_loc
,
13848 struct dwarf2_cu
*cu
)
13850 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13851 struct dwarf2_locexpr_baton
*baton
;
13853 unsigned int cu_off
;
13854 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
13855 LONGEST offset
= 0;
13857 gdb_assert (common_loc
&& member_loc
);
13858 gdb_assert (attr_form_is_block (common_loc
));
13859 gdb_assert (attr_form_is_block (member_loc
)
13860 || attr_form_is_constant (member_loc
));
13862 baton
= obstack_alloc (&objfile
->objfile_obstack
,
13863 sizeof (struct dwarf2_locexpr_baton
));
13864 baton
->per_cu
= cu
->per_cu
;
13865 gdb_assert (baton
->per_cu
);
13867 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13869 if (attr_form_is_constant (member_loc
))
13871 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
13872 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
13875 baton
->size
+= DW_BLOCK (member_loc
)->size
;
13877 ptr
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
13880 *ptr
++ = DW_OP_call4
;
13881 cu_off
= common_die
->offset
.sect_off
- cu
->per_cu
->offset
.sect_off
;
13882 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
13885 if (attr_form_is_constant (member_loc
))
13887 *ptr
++ = DW_OP_addr
;
13888 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
13889 ptr
+= cu
->header
.addr_size
;
13893 /* We have to copy the data here, because DW_OP_call4 will only
13894 use a DW_AT_location attribute. */
13895 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
13896 ptr
+= DW_BLOCK (member_loc
)->size
;
13899 *ptr
++ = DW_OP_plus
;
13900 gdb_assert (ptr
- baton
->data
== baton
->size
);
13902 SYMBOL_LOCATION_BATON (sym
) = baton
;
13903 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
13906 /* Create appropriate locally-scoped variables for all the
13907 DW_TAG_common_block entries. Also create a struct common_block
13908 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13909 is used to sepate the common blocks name namespace from regular
13913 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
13915 struct attribute
*attr
;
13917 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13920 /* Support the .debug_loc offsets. */
13921 if (attr_form_is_block (attr
))
13925 else if (attr_form_is_section_offset (attr
))
13927 dwarf2_complex_location_expr_complaint ();
13932 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13933 "common block member");
13938 if (die
->child
!= NULL
)
13940 struct objfile
*objfile
= cu
->objfile
;
13941 struct die_info
*child_die
;
13942 size_t n_entries
= 0, size
;
13943 struct common_block
*common_block
;
13944 struct symbol
*sym
;
13946 for (child_die
= die
->child
;
13947 child_die
&& child_die
->tag
;
13948 child_die
= sibling_die (child_die
))
13951 size
= (sizeof (struct common_block
)
13952 + (n_entries
- 1) * sizeof (struct symbol
*));
13953 common_block
= obstack_alloc (&objfile
->objfile_obstack
, size
);
13954 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
13955 common_block
->n_entries
= 0;
13957 for (child_die
= die
->child
;
13958 child_die
&& child_die
->tag
;
13959 child_die
= sibling_die (child_die
))
13961 /* Create the symbol in the DW_TAG_common_block block in the current
13963 sym
= new_symbol (child_die
, NULL
, cu
);
13966 struct attribute
*member_loc
;
13968 common_block
->contents
[common_block
->n_entries
++] = sym
;
13970 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
13974 /* GDB has handled this for a long time, but it is
13975 not specified by DWARF. It seems to have been
13976 emitted by gfortran at least as recently as:
13977 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
13978 complaint (&symfile_complaints
,
13979 _("Variable in common block has "
13980 "DW_AT_data_member_location "
13981 "- DIE at 0x%x [in module %s]"),
13982 child_die
->offset
.sect_off
,
13983 objfile_name (cu
->objfile
));
13985 if (attr_form_is_section_offset (member_loc
))
13986 dwarf2_complex_location_expr_complaint ();
13987 else if (attr_form_is_constant (member_loc
)
13988 || attr_form_is_block (member_loc
))
13991 mark_common_block_symbol_computed (sym
, die
, attr
,
13995 dwarf2_complex_location_expr_complaint ();
14000 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
14001 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
14005 /* Create a type for a C++ namespace. */
14007 static struct type
*
14008 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14010 struct objfile
*objfile
= cu
->objfile
;
14011 const char *previous_prefix
, *name
;
14015 /* For extensions, reuse the type of the original namespace. */
14016 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
14018 struct die_info
*ext_die
;
14019 struct dwarf2_cu
*ext_cu
= cu
;
14021 ext_die
= dwarf2_extension (die
, &ext_cu
);
14022 type
= read_type_die (ext_die
, ext_cu
);
14024 /* EXT_CU may not be the same as CU.
14025 Ensure TYPE is recorded with CU in die_type_hash. */
14026 return set_die_type (die
, type
, cu
);
14029 name
= namespace_name (die
, &is_anonymous
, cu
);
14031 /* Now build the name of the current namespace. */
14033 previous_prefix
= determine_prefix (die
, cu
);
14034 if (previous_prefix
[0] != '\0')
14035 name
= typename_concat (&objfile
->objfile_obstack
,
14036 previous_prefix
, name
, 0, cu
);
14038 /* Create the type. */
14039 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
14041 TYPE_NAME (type
) = name
;
14042 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14044 return set_die_type (die
, type
, cu
);
14047 /* Read a C++ namespace. */
14050 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
14052 struct objfile
*objfile
= cu
->objfile
;
14055 /* Add a symbol associated to this if we haven't seen the namespace
14056 before. Also, add a using directive if it's an anonymous
14059 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
14063 type
= read_type_die (die
, cu
);
14064 new_symbol (die
, type
, cu
);
14066 namespace_name (die
, &is_anonymous
, cu
);
14069 const char *previous_prefix
= determine_prefix (die
, cu
);
14071 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
14072 NULL
, NULL
, 0, &objfile
->objfile_obstack
);
14076 if (die
->child
!= NULL
)
14078 struct die_info
*child_die
= die
->child
;
14080 while (child_die
&& child_die
->tag
)
14082 process_die (child_die
, cu
);
14083 child_die
= sibling_die (child_die
);
14088 /* Read a Fortran module as type. This DIE can be only a declaration used for
14089 imported module. Still we need that type as local Fortran "use ... only"
14090 declaration imports depend on the created type in determine_prefix. */
14092 static struct type
*
14093 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14095 struct objfile
*objfile
= cu
->objfile
;
14096 const char *module_name
;
14099 module_name
= dwarf2_name (die
, cu
);
14101 complaint (&symfile_complaints
,
14102 _("DW_TAG_module has no name, offset 0x%x"),
14103 die
->offset
.sect_off
);
14104 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
14106 /* determine_prefix uses TYPE_TAG_NAME. */
14107 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14109 return set_die_type (die
, type
, cu
);
14112 /* Read a Fortran module. */
14115 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
14117 struct die_info
*child_die
= die
->child
;
14120 type
= read_type_die (die
, cu
);
14121 new_symbol (die
, type
, cu
);
14123 while (child_die
&& child_die
->tag
)
14125 process_die (child_die
, cu
);
14126 child_die
= sibling_die (child_die
);
14130 /* Return the name of the namespace represented by DIE. Set
14131 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
14134 static const char *
14135 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
14137 struct die_info
*current_die
;
14138 const char *name
= NULL
;
14140 /* Loop through the extensions until we find a name. */
14142 for (current_die
= die
;
14143 current_die
!= NULL
;
14144 current_die
= dwarf2_extension (die
, &cu
))
14146 /* We don't use dwarf2_name here so that we can detect the absence
14147 of a name -> anonymous namespace. */
14148 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
14151 name
= DW_STRING (attr
);
14156 /* Is it an anonymous namespace? */
14158 *is_anonymous
= (name
== NULL
);
14160 name
= CP_ANONYMOUS_NAMESPACE_STR
;
14165 /* Extract all information from a DW_TAG_pointer_type DIE and add to
14166 the user defined type vector. */
14168 static struct type
*
14169 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14171 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
14172 struct comp_unit_head
*cu_header
= &cu
->header
;
14174 struct attribute
*attr_byte_size
;
14175 struct attribute
*attr_address_class
;
14176 int byte_size
, addr_class
;
14177 struct type
*target_type
;
14179 target_type
= die_type (die
, cu
);
14181 /* The die_type call above may have already set the type for this DIE. */
14182 type
= get_die_type (die
, cu
);
14186 type
= lookup_pointer_type (target_type
);
14188 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14189 if (attr_byte_size
)
14190 byte_size
= DW_UNSND (attr_byte_size
);
14192 byte_size
= cu_header
->addr_size
;
14194 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
14195 if (attr_address_class
)
14196 addr_class
= DW_UNSND (attr_address_class
);
14198 addr_class
= DW_ADDR_none
;
14200 /* If the pointer size or address class is different than the
14201 default, create a type variant marked as such and set the
14202 length accordingly. */
14203 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
14205 if (gdbarch_address_class_type_flags_p (gdbarch
))
14209 type_flags
= gdbarch_address_class_type_flags
14210 (gdbarch
, byte_size
, addr_class
);
14211 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
14213 type
= make_type_with_address_space (type
, type_flags
);
14215 else if (TYPE_LENGTH (type
) != byte_size
)
14217 complaint (&symfile_complaints
,
14218 _("invalid pointer size %d"), byte_size
);
14222 /* Should we also complain about unhandled address classes? */
14226 TYPE_LENGTH (type
) = byte_size
;
14227 return set_die_type (die
, type
, cu
);
14230 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14231 the user defined type vector. */
14233 static struct type
*
14234 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14237 struct type
*to_type
;
14238 struct type
*domain
;
14240 to_type
= die_type (die
, cu
);
14241 domain
= die_containing_type (die
, cu
);
14243 /* The calls above may have already set the type for this DIE. */
14244 type
= get_die_type (die
, cu
);
14248 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
14249 type
= lookup_methodptr_type (to_type
);
14250 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
14252 struct type
*new_type
= alloc_type (cu
->objfile
);
14254 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
14255 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
14256 TYPE_VARARGS (to_type
));
14257 type
= lookup_methodptr_type (new_type
);
14260 type
= lookup_memberptr_type (to_type
, domain
);
14262 return set_die_type (die
, type
, cu
);
14265 /* Extract all information from a DW_TAG_reference_type DIE and add to
14266 the user defined type vector. */
14268 static struct type
*
14269 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14271 struct comp_unit_head
*cu_header
= &cu
->header
;
14272 struct type
*type
, *target_type
;
14273 struct attribute
*attr
;
14275 target_type
= die_type (die
, cu
);
14277 /* The die_type call above may have already set the type for this DIE. */
14278 type
= get_die_type (die
, cu
);
14282 type
= lookup_reference_type (target_type
);
14283 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14286 TYPE_LENGTH (type
) = DW_UNSND (attr
);
14290 TYPE_LENGTH (type
) = cu_header
->addr_size
;
14292 return set_die_type (die
, type
, cu
);
14295 /* Add the given cv-qualifiers to the element type of the array. GCC
14296 outputs DWARF type qualifiers that apply to an array, not the
14297 element type. But GDB relies on the array element type to carry
14298 the cv-qualifiers. This mimics section 6.7.3 of the C99
14301 static struct type
*
14302 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
14303 struct type
*base_type
, int cnst
, int voltl
)
14305 struct type
*el_type
, *inner_array
;
14307 base_type
= copy_type (base_type
);
14308 inner_array
= base_type
;
14310 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
14312 TYPE_TARGET_TYPE (inner_array
) =
14313 copy_type (TYPE_TARGET_TYPE (inner_array
));
14314 inner_array
= TYPE_TARGET_TYPE (inner_array
);
14317 el_type
= TYPE_TARGET_TYPE (inner_array
);
14318 cnst
|= TYPE_CONST (el_type
);
14319 voltl
|= TYPE_VOLATILE (el_type
);
14320 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
14322 return set_die_type (die
, base_type
, cu
);
14325 static struct type
*
14326 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14328 struct type
*base_type
, *cv_type
;
14330 base_type
= die_type (die
, cu
);
14332 /* The die_type call above may have already set the type for this DIE. */
14333 cv_type
= get_die_type (die
, cu
);
14337 /* In case the const qualifier is applied to an array type, the element type
14338 is so qualified, not the array type (section 6.7.3 of C99). */
14339 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14340 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
14342 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
14343 return set_die_type (die
, cv_type
, cu
);
14346 static struct type
*
14347 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14349 struct type
*base_type
, *cv_type
;
14351 base_type
= die_type (die
, cu
);
14353 /* The die_type call above may have already set the type for this DIE. */
14354 cv_type
= get_die_type (die
, cu
);
14358 /* In case the volatile qualifier is applied to an array type, the
14359 element type is so qualified, not the array type (section 6.7.3
14361 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14362 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
14364 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
14365 return set_die_type (die
, cv_type
, cu
);
14368 /* Handle DW_TAG_restrict_type. */
14370 static struct type
*
14371 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14373 struct type
*base_type
, *cv_type
;
14375 base_type
= die_type (die
, cu
);
14377 /* The die_type call above may have already set the type for this DIE. */
14378 cv_type
= get_die_type (die
, cu
);
14382 cv_type
= make_restrict_type (base_type
);
14383 return set_die_type (die
, cv_type
, cu
);
14386 /* Handle DW_TAG_atomic_type. */
14388 static struct type
*
14389 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14391 struct type
*base_type
, *cv_type
;
14393 base_type
= die_type (die
, cu
);
14395 /* The die_type call above may have already set the type for this DIE. */
14396 cv_type
= get_die_type (die
, cu
);
14400 cv_type
= make_atomic_type (base_type
);
14401 return set_die_type (die
, cv_type
, cu
);
14404 /* Extract all information from a DW_TAG_string_type DIE and add to
14405 the user defined type vector. It isn't really a user defined type,
14406 but it behaves like one, with other DIE's using an AT_user_def_type
14407 attribute to reference it. */
14409 static struct type
*
14410 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14412 struct objfile
*objfile
= cu
->objfile
;
14413 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14414 struct type
*type
, *range_type
, *index_type
, *char_type
;
14415 struct attribute
*attr
;
14416 unsigned int length
;
14418 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
14421 length
= DW_UNSND (attr
);
14425 /* Check for the DW_AT_byte_size attribute. */
14426 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14429 length
= DW_UNSND (attr
);
14437 index_type
= objfile_type (objfile
)->builtin_int
;
14438 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
14439 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
14440 type
= create_string_type (NULL
, char_type
, range_type
);
14442 return set_die_type (die
, type
, cu
);
14445 /* Assuming that DIE corresponds to a function, returns nonzero
14446 if the function is prototyped. */
14449 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
14451 struct attribute
*attr
;
14453 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
14454 if (attr
&& (DW_UNSND (attr
) != 0))
14457 /* The DWARF standard implies that the DW_AT_prototyped attribute
14458 is only meaninful for C, but the concept also extends to other
14459 languages that allow unprototyped functions (Eg: Objective C).
14460 For all other languages, assume that functions are always
14462 if (cu
->language
!= language_c
14463 && cu
->language
!= language_objc
14464 && cu
->language
!= language_opencl
)
14467 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14468 prototyped and unprototyped functions; default to prototyped,
14469 since that is more common in modern code (and RealView warns
14470 about unprototyped functions). */
14471 if (producer_is_realview (cu
->producer
))
14477 /* Handle DIES due to C code like:
14481 int (*funcp)(int a, long l);
14485 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14487 static struct type
*
14488 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14490 struct objfile
*objfile
= cu
->objfile
;
14491 struct type
*type
; /* Type that this function returns. */
14492 struct type
*ftype
; /* Function that returns above type. */
14493 struct attribute
*attr
;
14495 type
= die_type (die
, cu
);
14497 /* The die_type call above may have already set the type for this DIE. */
14498 ftype
= get_die_type (die
, cu
);
14502 ftype
= lookup_function_type (type
);
14504 if (prototyped_function_p (die
, cu
))
14505 TYPE_PROTOTYPED (ftype
) = 1;
14507 /* Store the calling convention in the type if it's available in
14508 the subroutine die. Otherwise set the calling convention to
14509 the default value DW_CC_normal. */
14510 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
14512 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
14513 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
14514 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
14516 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
14518 /* Record whether the function returns normally to its caller or not
14519 if the DWARF producer set that information. */
14520 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
14521 if (attr
&& (DW_UNSND (attr
) != 0))
14522 TYPE_NO_RETURN (ftype
) = 1;
14524 /* We need to add the subroutine type to the die immediately so
14525 we don't infinitely recurse when dealing with parameters
14526 declared as the same subroutine type. */
14527 set_die_type (die
, ftype
, cu
);
14529 if (die
->child
!= NULL
)
14531 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
14532 struct die_info
*child_die
;
14533 int nparams
, iparams
;
14535 /* Count the number of parameters.
14536 FIXME: GDB currently ignores vararg functions, but knows about
14537 vararg member functions. */
14539 child_die
= die
->child
;
14540 while (child_die
&& child_die
->tag
)
14542 if (child_die
->tag
== DW_TAG_formal_parameter
)
14544 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
14545 TYPE_VARARGS (ftype
) = 1;
14546 child_die
= sibling_die (child_die
);
14549 /* Allocate storage for parameters and fill them in. */
14550 TYPE_NFIELDS (ftype
) = nparams
;
14551 TYPE_FIELDS (ftype
) = (struct field
*)
14552 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
14554 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14555 even if we error out during the parameters reading below. */
14556 for (iparams
= 0; iparams
< nparams
; iparams
++)
14557 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
14560 child_die
= die
->child
;
14561 while (child_die
&& child_die
->tag
)
14563 if (child_die
->tag
== DW_TAG_formal_parameter
)
14565 struct type
*arg_type
;
14567 /* DWARF version 2 has no clean way to discern C++
14568 static and non-static member functions. G++ helps
14569 GDB by marking the first parameter for non-static
14570 member functions (which is the this pointer) as
14571 artificial. We pass this information to
14572 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14574 DWARF version 3 added DW_AT_object_pointer, which GCC
14575 4.5 does not yet generate. */
14576 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
14578 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
14581 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
14583 /* GCC/43521: In java, the formal parameter
14584 "this" is sometimes not marked with DW_AT_artificial. */
14585 if (cu
->language
== language_java
)
14587 const char *name
= dwarf2_name (child_die
, cu
);
14589 if (name
&& !strcmp (name
, "this"))
14590 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
14593 arg_type
= die_type (child_die
, cu
);
14595 /* RealView does not mark THIS as const, which the testsuite
14596 expects. GCC marks THIS as const in method definitions,
14597 but not in the class specifications (GCC PR 43053). */
14598 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
14599 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
14602 struct dwarf2_cu
*arg_cu
= cu
;
14603 const char *name
= dwarf2_name (child_die
, cu
);
14605 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
14608 /* If the compiler emits this, use it. */
14609 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
14612 else if (name
&& strcmp (name
, "this") == 0)
14613 /* Function definitions will have the argument names. */
14615 else if (name
== NULL
&& iparams
== 0)
14616 /* Declarations may not have the names, so like
14617 elsewhere in GDB, assume an artificial first
14618 argument is "this". */
14622 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
14626 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
14629 child_die
= sibling_die (child_die
);
14636 static struct type
*
14637 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
14639 struct objfile
*objfile
= cu
->objfile
;
14640 const char *name
= NULL
;
14641 struct type
*this_type
, *target_type
;
14643 name
= dwarf2_full_name (NULL
, die
, cu
);
14644 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
14645 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
14646 TYPE_NAME (this_type
) = name
;
14647 set_die_type (die
, this_type
, cu
);
14648 target_type
= die_type (die
, cu
);
14649 if (target_type
!= this_type
)
14650 TYPE_TARGET_TYPE (this_type
) = target_type
;
14653 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14654 spec and cause infinite loops in GDB. */
14655 complaint (&symfile_complaints
,
14656 _("Self-referential DW_TAG_typedef "
14657 "- DIE at 0x%x [in module %s]"),
14658 die
->offset
.sect_off
, objfile_name (objfile
));
14659 TYPE_TARGET_TYPE (this_type
) = NULL
;
14664 /* Find a representation of a given base type and install
14665 it in the TYPE field of the die. */
14667 static struct type
*
14668 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14670 struct objfile
*objfile
= cu
->objfile
;
14672 struct attribute
*attr
;
14673 int encoding
= 0, size
= 0;
14675 enum type_code code
= TYPE_CODE_INT
;
14676 int type_flags
= 0;
14677 struct type
*target_type
= NULL
;
14679 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
14682 encoding
= DW_UNSND (attr
);
14684 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14687 size
= DW_UNSND (attr
);
14689 name
= dwarf2_name (die
, cu
);
14692 complaint (&symfile_complaints
,
14693 _("DW_AT_name missing from DW_TAG_base_type"));
14698 case DW_ATE_address
:
14699 /* Turn DW_ATE_address into a void * pointer. */
14700 code
= TYPE_CODE_PTR
;
14701 type_flags
|= TYPE_FLAG_UNSIGNED
;
14702 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
14704 case DW_ATE_boolean
:
14705 code
= TYPE_CODE_BOOL
;
14706 type_flags
|= TYPE_FLAG_UNSIGNED
;
14708 case DW_ATE_complex_float
:
14709 code
= TYPE_CODE_COMPLEX
;
14710 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
14712 case DW_ATE_decimal_float
:
14713 code
= TYPE_CODE_DECFLOAT
;
14716 code
= TYPE_CODE_FLT
;
14718 case DW_ATE_signed
:
14720 case DW_ATE_unsigned
:
14721 type_flags
|= TYPE_FLAG_UNSIGNED
;
14722 if (cu
->language
== language_fortran
14724 && startswith (name
, "character("))
14725 code
= TYPE_CODE_CHAR
;
14727 case DW_ATE_signed_char
:
14728 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14729 || cu
->language
== language_pascal
14730 || cu
->language
== language_fortran
)
14731 code
= TYPE_CODE_CHAR
;
14733 case DW_ATE_unsigned_char
:
14734 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14735 || cu
->language
== language_pascal
14736 || cu
->language
== language_fortran
)
14737 code
= TYPE_CODE_CHAR
;
14738 type_flags
|= TYPE_FLAG_UNSIGNED
;
14741 /* We just treat this as an integer and then recognize the
14742 type by name elsewhere. */
14746 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
14747 dwarf_type_encoding_name (encoding
));
14751 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
14752 TYPE_NAME (type
) = name
;
14753 TYPE_TARGET_TYPE (type
) = target_type
;
14755 if (name
&& strcmp (name
, "char") == 0)
14756 TYPE_NOSIGN (type
) = 1;
14758 return set_die_type (die
, type
, cu
);
14761 /* Parse dwarf attribute if it's a block, reference or constant and put the
14762 resulting value of the attribute into struct bound_prop.
14763 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14766 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
14767 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
14769 struct dwarf2_property_baton
*baton
;
14770 struct obstack
*obstack
= &cu
->objfile
->objfile_obstack
;
14772 if (attr
== NULL
|| prop
== NULL
)
14775 if (attr_form_is_block (attr
))
14777 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14778 baton
->referenced_type
= NULL
;
14779 baton
->locexpr
.per_cu
= cu
->per_cu
;
14780 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
14781 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
14782 prop
->data
.baton
= baton
;
14783 prop
->kind
= PROP_LOCEXPR
;
14784 gdb_assert (prop
->data
.baton
!= NULL
);
14786 else if (attr_form_is_ref (attr
))
14788 struct dwarf2_cu
*target_cu
= cu
;
14789 struct die_info
*target_die
;
14790 struct attribute
*target_attr
;
14792 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14793 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
14794 if (target_attr
== NULL
)
14795 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
14797 if (target_attr
== NULL
)
14800 switch (target_attr
->name
)
14802 case DW_AT_location
:
14803 if (attr_form_is_section_offset (target_attr
))
14805 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14806 baton
->referenced_type
= die_type (target_die
, target_cu
);
14807 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
14808 prop
->data
.baton
= baton
;
14809 prop
->kind
= PROP_LOCLIST
;
14810 gdb_assert (prop
->data
.baton
!= NULL
);
14812 else if (attr_form_is_block (target_attr
))
14814 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14815 baton
->referenced_type
= die_type (target_die
, target_cu
);
14816 baton
->locexpr
.per_cu
= cu
->per_cu
;
14817 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
14818 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
14819 prop
->data
.baton
= baton
;
14820 prop
->kind
= PROP_LOCEXPR
;
14821 gdb_assert (prop
->data
.baton
!= NULL
);
14825 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14826 "dynamic property");
14830 case DW_AT_data_member_location
:
14834 if (!handle_data_member_location (target_die
, target_cu
,
14838 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14839 baton
->referenced_type
= get_die_type (target_die
->parent
,
14841 baton
->offset_info
.offset
= offset
;
14842 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
14843 prop
->data
.baton
= baton
;
14844 prop
->kind
= PROP_ADDR_OFFSET
;
14849 else if (attr_form_is_constant (attr
))
14851 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
14852 prop
->kind
= PROP_CONST
;
14856 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
14857 dwarf2_name (die
, cu
));
14864 /* Read the given DW_AT_subrange DIE. */
14866 static struct type
*
14867 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14869 struct type
*base_type
, *orig_base_type
;
14870 struct type
*range_type
;
14871 struct attribute
*attr
;
14872 struct dynamic_prop low
, high
;
14873 int low_default_is_valid
;
14874 int high_bound_is_count
= 0;
14876 LONGEST negative_mask
;
14878 orig_base_type
= die_type (die
, cu
);
14879 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14880 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14881 creating the range type, but we use the result of check_typedef
14882 when examining properties of the type. */
14883 base_type
= check_typedef (orig_base_type
);
14885 /* The die_type call above may have already set the type for this DIE. */
14886 range_type
= get_die_type (die
, cu
);
14890 low
.kind
= PROP_CONST
;
14891 high
.kind
= PROP_CONST
;
14892 high
.data
.const_val
= 0;
14894 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14895 omitting DW_AT_lower_bound. */
14896 switch (cu
->language
)
14899 case language_cplus
:
14900 low
.data
.const_val
= 0;
14901 low_default_is_valid
= 1;
14903 case language_fortran
:
14904 low
.data
.const_val
= 1;
14905 low_default_is_valid
= 1;
14908 case language_java
:
14909 case language_objc
:
14910 low
.data
.const_val
= 0;
14911 low_default_is_valid
= (cu
->header
.version
>= 4);
14915 case language_pascal
:
14916 low
.data
.const_val
= 1;
14917 low_default_is_valid
= (cu
->header
.version
>= 4);
14920 low
.data
.const_val
= 0;
14921 low_default_is_valid
= 0;
14925 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
14927 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
14928 else if (!low_default_is_valid
)
14929 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
14930 "- DIE at 0x%x [in module %s]"),
14931 die
->offset
.sect_off
, objfile_name (cu
->objfile
));
14933 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
14934 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14936 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
14937 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14939 /* If bounds are constant do the final calculation here. */
14940 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
14941 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
14943 high_bound_is_count
= 1;
14947 /* Dwarf-2 specifications explicitly allows to create subrange types
14948 without specifying a base type.
14949 In that case, the base type must be set to the type of
14950 the lower bound, upper bound or count, in that order, if any of these
14951 three attributes references an object that has a type.
14952 If no base type is found, the Dwarf-2 specifications say that
14953 a signed integer type of size equal to the size of an address should
14955 For the following C code: `extern char gdb_int [];'
14956 GCC produces an empty range DIE.
14957 FIXME: muller/2010-05-28: Possible references to object for low bound,
14958 high bound or count are not yet handled by this code. */
14959 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
14961 struct objfile
*objfile
= cu
->objfile
;
14962 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14963 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
14964 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
14966 /* Test "int", "long int", and "long long int" objfile types,
14967 and select the first one having a size above or equal to the
14968 architecture address size. */
14969 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14970 base_type
= int_type
;
14973 int_type
= objfile_type (objfile
)->builtin_long
;
14974 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14975 base_type
= int_type
;
14978 int_type
= objfile_type (objfile
)->builtin_long_long
;
14979 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14980 base_type
= int_type
;
14985 /* Normally, the DWARF producers are expected to use a signed
14986 constant form (Eg. DW_FORM_sdata) to express negative bounds.
14987 But this is unfortunately not always the case, as witnessed
14988 with GCC, for instance, where the ambiguous DW_FORM_dataN form
14989 is used instead. To work around that ambiguity, we treat
14990 the bounds as signed, and thus sign-extend their values, when
14991 the base type is signed. */
14993 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
14994 if (low
.kind
== PROP_CONST
14995 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
14996 low
.data
.const_val
|= negative_mask
;
14997 if (high
.kind
== PROP_CONST
14998 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
14999 high
.data
.const_val
|= negative_mask
;
15001 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
15003 if (high_bound_is_count
)
15004 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
15006 /* Ada expects an empty array on no boundary attributes. */
15007 if (attr
== NULL
&& cu
->language
!= language_ada
)
15008 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
15010 name
= dwarf2_name (die
, cu
);
15012 TYPE_NAME (range_type
) = name
;
15014 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15016 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
15018 set_die_type (die
, range_type
, cu
);
15020 /* set_die_type should be already done. */
15021 set_descriptive_type (range_type
, die
, cu
);
15026 static struct type
*
15027 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15031 /* For now, we only support the C meaning of an unspecified type: void. */
15033 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
15034 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
15036 return set_die_type (die
, type
, cu
);
15039 /* Read a single die and all its descendents. Set the die's sibling
15040 field to NULL; set other fields in the die correctly, and set all
15041 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
15042 location of the info_ptr after reading all of those dies. PARENT
15043 is the parent of the die in question. */
15045 static struct die_info
*
15046 read_die_and_children (const struct die_reader_specs
*reader
,
15047 const gdb_byte
*info_ptr
,
15048 const gdb_byte
**new_info_ptr
,
15049 struct die_info
*parent
)
15051 struct die_info
*die
;
15052 const gdb_byte
*cur_ptr
;
15055 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
15058 *new_info_ptr
= cur_ptr
;
15061 store_in_ref_table (die
, reader
->cu
);
15064 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
15068 *new_info_ptr
= cur_ptr
;
15071 die
->sibling
= NULL
;
15072 die
->parent
= parent
;
15076 /* Read a die, all of its descendents, and all of its siblings; set
15077 all of the fields of all of the dies correctly. Arguments are as
15078 in read_die_and_children. */
15080 static struct die_info
*
15081 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
15082 const gdb_byte
*info_ptr
,
15083 const gdb_byte
**new_info_ptr
,
15084 struct die_info
*parent
)
15086 struct die_info
*first_die
, *last_sibling
;
15087 const gdb_byte
*cur_ptr
;
15089 cur_ptr
= info_ptr
;
15090 first_die
= last_sibling
= NULL
;
15094 struct die_info
*die
15095 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
15099 *new_info_ptr
= cur_ptr
;
15106 last_sibling
->sibling
= die
;
15108 last_sibling
= die
;
15112 /* Read a die, all of its descendents, and all of its siblings; set
15113 all of the fields of all of the dies correctly. Arguments are as
15114 in read_die_and_children.
15115 This the main entry point for reading a DIE and all its children. */
15117 static struct die_info
*
15118 read_die_and_siblings (const struct die_reader_specs
*reader
,
15119 const gdb_byte
*info_ptr
,
15120 const gdb_byte
**new_info_ptr
,
15121 struct die_info
*parent
)
15123 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
15124 new_info_ptr
, parent
);
15126 if (dwarf2_die_debug
)
15128 fprintf_unfiltered (gdb_stdlog
,
15129 "Read die from %s@0x%x of %s:\n",
15130 get_section_name (reader
->die_section
),
15131 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15132 bfd_get_filename (reader
->abfd
));
15133 dump_die (die
, dwarf2_die_debug
);
15139 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
15141 The caller is responsible for filling in the extra attributes
15142 and updating (*DIEP)->num_attrs.
15143 Set DIEP to point to a newly allocated die with its information,
15144 except for its child, sibling, and parent fields.
15145 Set HAS_CHILDREN to tell whether the die has children or not. */
15147 static const gdb_byte
*
15148 read_full_die_1 (const struct die_reader_specs
*reader
,
15149 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15150 int *has_children
, int num_extra_attrs
)
15152 unsigned int abbrev_number
, bytes_read
, i
;
15153 sect_offset offset
;
15154 struct abbrev_info
*abbrev
;
15155 struct die_info
*die
;
15156 struct dwarf2_cu
*cu
= reader
->cu
;
15157 bfd
*abfd
= reader
->abfd
;
15159 offset
.sect_off
= info_ptr
- reader
->buffer
;
15160 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15161 info_ptr
+= bytes_read
;
15162 if (!abbrev_number
)
15169 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
15171 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
15173 bfd_get_filename (abfd
));
15175 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
15176 die
->offset
= offset
;
15177 die
->tag
= abbrev
->tag
;
15178 die
->abbrev
= abbrev_number
;
15180 /* Make the result usable.
15181 The caller needs to update num_attrs after adding the extra
15183 die
->num_attrs
= abbrev
->num_attrs
;
15185 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15186 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
15190 *has_children
= abbrev
->has_children
;
15194 /* Read a die and all its attributes.
15195 Set DIEP to point to a newly allocated die with its information,
15196 except for its child, sibling, and parent fields.
15197 Set HAS_CHILDREN to tell whether the die has children or not. */
15199 static const gdb_byte
*
15200 read_full_die (const struct die_reader_specs
*reader
,
15201 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15204 const gdb_byte
*result
;
15206 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
15208 if (dwarf2_die_debug
)
15210 fprintf_unfiltered (gdb_stdlog
,
15211 "Read die from %s@0x%x of %s:\n",
15212 get_section_name (reader
->die_section
),
15213 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15214 bfd_get_filename (reader
->abfd
));
15215 dump_die (*diep
, dwarf2_die_debug
);
15221 /* Abbreviation tables.
15223 In DWARF version 2, the description of the debugging information is
15224 stored in a separate .debug_abbrev section. Before we read any
15225 dies from a section we read in all abbreviations and install them
15226 in a hash table. */
15228 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
15230 static struct abbrev_info
*
15231 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
15233 struct abbrev_info
*abbrev
;
15235 abbrev
= (struct abbrev_info
*)
15236 obstack_alloc (&abbrev_table
->abbrev_obstack
, sizeof (struct abbrev_info
));
15237 memset (abbrev
, 0, sizeof (struct abbrev_info
));
15241 /* Add an abbreviation to the table. */
15244 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
15245 unsigned int abbrev_number
,
15246 struct abbrev_info
*abbrev
)
15248 unsigned int hash_number
;
15250 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15251 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
15252 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
15255 /* Look up an abbrev in the table.
15256 Returns NULL if the abbrev is not found. */
15258 static struct abbrev_info
*
15259 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
15260 unsigned int abbrev_number
)
15262 unsigned int hash_number
;
15263 struct abbrev_info
*abbrev
;
15265 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15266 abbrev
= abbrev_table
->abbrevs
[hash_number
];
15270 if (abbrev
->number
== abbrev_number
)
15272 abbrev
= abbrev
->next
;
15277 /* Read in an abbrev table. */
15279 static struct abbrev_table
*
15280 abbrev_table_read_table (struct dwarf2_section_info
*section
,
15281 sect_offset offset
)
15283 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15284 bfd
*abfd
= get_section_bfd_owner (section
);
15285 struct abbrev_table
*abbrev_table
;
15286 const gdb_byte
*abbrev_ptr
;
15287 struct abbrev_info
*cur_abbrev
;
15288 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
15289 unsigned int abbrev_form
;
15290 struct attr_abbrev
*cur_attrs
;
15291 unsigned int allocated_attrs
;
15293 abbrev_table
= XNEW (struct abbrev_table
);
15294 abbrev_table
->offset
= offset
;
15295 obstack_init (&abbrev_table
->abbrev_obstack
);
15296 abbrev_table
->abbrevs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15298 * sizeof (struct abbrev_info
*)));
15299 memset (abbrev_table
->abbrevs
, 0,
15300 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
15302 dwarf2_read_section (objfile
, section
);
15303 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
15304 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15305 abbrev_ptr
+= bytes_read
;
15307 allocated_attrs
= ATTR_ALLOC_CHUNK
;
15308 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
15310 /* Loop until we reach an abbrev number of 0. */
15311 while (abbrev_number
)
15313 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
15315 /* read in abbrev header */
15316 cur_abbrev
->number
= abbrev_number
;
15317 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15318 abbrev_ptr
+= bytes_read
;
15319 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
15322 /* now read in declarations */
15323 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15324 abbrev_ptr
+= bytes_read
;
15325 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15326 abbrev_ptr
+= bytes_read
;
15327 while (abbrev_name
)
15329 if (cur_abbrev
->num_attrs
== allocated_attrs
)
15331 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
15333 = xrealloc (cur_attrs
, (allocated_attrs
15334 * sizeof (struct attr_abbrev
)));
15337 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
15338 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
15339 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15340 abbrev_ptr
+= bytes_read
;
15341 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15342 abbrev_ptr
+= bytes_read
;
15345 cur_abbrev
->attrs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15346 (cur_abbrev
->num_attrs
15347 * sizeof (struct attr_abbrev
)));
15348 memcpy (cur_abbrev
->attrs
, cur_attrs
,
15349 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
15351 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
15353 /* Get next abbreviation.
15354 Under Irix6 the abbreviations for a compilation unit are not
15355 always properly terminated with an abbrev number of 0.
15356 Exit loop if we encounter an abbreviation which we have
15357 already read (which means we are about to read the abbreviations
15358 for the next compile unit) or if the end of the abbreviation
15359 table is reached. */
15360 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
15362 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15363 abbrev_ptr
+= bytes_read
;
15364 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
15369 return abbrev_table
;
15372 /* Free the resources held by ABBREV_TABLE. */
15375 abbrev_table_free (struct abbrev_table
*abbrev_table
)
15377 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
15378 xfree (abbrev_table
);
15381 /* Same as abbrev_table_free but as a cleanup.
15382 We pass in a pointer to the pointer to the table so that we can
15383 set the pointer to NULL when we're done. It also simplifies
15384 build_type_psymtabs_1. */
15387 abbrev_table_free_cleanup (void *table_ptr
)
15389 struct abbrev_table
**abbrev_table_ptr
= table_ptr
;
15391 if (*abbrev_table_ptr
!= NULL
)
15392 abbrev_table_free (*abbrev_table_ptr
);
15393 *abbrev_table_ptr
= NULL
;
15396 /* Read the abbrev table for CU from ABBREV_SECTION. */
15399 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
15400 struct dwarf2_section_info
*abbrev_section
)
15403 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
15406 /* Release the memory used by the abbrev table for a compilation unit. */
15409 dwarf2_free_abbrev_table (void *ptr_to_cu
)
15411 struct dwarf2_cu
*cu
= ptr_to_cu
;
15413 if (cu
->abbrev_table
!= NULL
)
15414 abbrev_table_free (cu
->abbrev_table
);
15415 /* Set this to NULL so that we SEGV if we try to read it later,
15416 and also because free_comp_unit verifies this is NULL. */
15417 cu
->abbrev_table
= NULL
;
15420 /* Returns nonzero if TAG represents a type that we might generate a partial
15424 is_type_tag_for_partial (int tag
)
15429 /* Some types that would be reasonable to generate partial symbols for,
15430 that we don't at present. */
15431 case DW_TAG_array_type
:
15432 case DW_TAG_file_type
:
15433 case DW_TAG_ptr_to_member_type
:
15434 case DW_TAG_set_type
:
15435 case DW_TAG_string_type
:
15436 case DW_TAG_subroutine_type
:
15438 case DW_TAG_base_type
:
15439 case DW_TAG_class_type
:
15440 case DW_TAG_interface_type
:
15441 case DW_TAG_enumeration_type
:
15442 case DW_TAG_structure_type
:
15443 case DW_TAG_subrange_type
:
15444 case DW_TAG_typedef
:
15445 case DW_TAG_union_type
:
15452 /* Load all DIEs that are interesting for partial symbols into memory. */
15454 static struct partial_die_info
*
15455 load_partial_dies (const struct die_reader_specs
*reader
,
15456 const gdb_byte
*info_ptr
, int building_psymtab
)
15458 struct dwarf2_cu
*cu
= reader
->cu
;
15459 struct objfile
*objfile
= cu
->objfile
;
15460 struct partial_die_info
*part_die
;
15461 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
15462 struct abbrev_info
*abbrev
;
15463 unsigned int bytes_read
;
15464 unsigned int load_all
= 0;
15465 int nesting_level
= 1;
15470 gdb_assert (cu
->per_cu
!= NULL
);
15471 if (cu
->per_cu
->load_all_dies
)
15475 = htab_create_alloc_ex (cu
->header
.length
/ 12,
15479 &cu
->comp_unit_obstack
,
15480 hashtab_obstack_allocate
,
15481 dummy_obstack_deallocate
);
15483 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15484 sizeof (struct partial_die_info
));
15488 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
15490 /* A NULL abbrev means the end of a series of children. */
15491 if (abbrev
== NULL
)
15493 if (--nesting_level
== 0)
15495 /* PART_DIE was probably the last thing allocated on the
15496 comp_unit_obstack, so we could call obstack_free
15497 here. We don't do that because the waste is small,
15498 and will be cleaned up when we're done with this
15499 compilation unit. This way, we're also more robust
15500 against other users of the comp_unit_obstack. */
15503 info_ptr
+= bytes_read
;
15504 last_die
= parent_die
;
15505 parent_die
= parent_die
->die_parent
;
15509 /* Check for template arguments. We never save these; if
15510 they're seen, we just mark the parent, and go on our way. */
15511 if (parent_die
!= NULL
15512 && cu
->language
== language_cplus
15513 && (abbrev
->tag
== DW_TAG_template_type_param
15514 || abbrev
->tag
== DW_TAG_template_value_param
))
15516 parent_die
->has_template_arguments
= 1;
15520 /* We don't need a partial DIE for the template argument. */
15521 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15526 /* We only recurse into c++ subprograms looking for template arguments.
15527 Skip their other children. */
15529 && cu
->language
== language_cplus
15530 && parent_die
!= NULL
15531 && parent_die
->tag
== DW_TAG_subprogram
)
15533 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15537 /* Check whether this DIE is interesting enough to save. Normally
15538 we would not be interested in members here, but there may be
15539 later variables referencing them via DW_AT_specification (for
15540 static members). */
15542 && !is_type_tag_for_partial (abbrev
->tag
)
15543 && abbrev
->tag
!= DW_TAG_constant
15544 && abbrev
->tag
!= DW_TAG_enumerator
15545 && abbrev
->tag
!= DW_TAG_subprogram
15546 && abbrev
->tag
!= DW_TAG_lexical_block
15547 && abbrev
->tag
!= DW_TAG_variable
15548 && abbrev
->tag
!= DW_TAG_namespace
15549 && abbrev
->tag
!= DW_TAG_module
15550 && abbrev
->tag
!= DW_TAG_member
15551 && abbrev
->tag
!= DW_TAG_imported_unit
15552 && abbrev
->tag
!= DW_TAG_imported_declaration
)
15554 /* Otherwise we skip to the next sibling, if any. */
15555 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15559 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
15562 /* This two-pass algorithm for processing partial symbols has a
15563 high cost in cache pressure. Thus, handle some simple cases
15564 here which cover the majority of C partial symbols. DIEs
15565 which neither have specification tags in them, nor could have
15566 specification tags elsewhere pointing at them, can simply be
15567 processed and discarded.
15569 This segment is also optional; scan_partial_symbols and
15570 add_partial_symbol will handle these DIEs if we chain
15571 them in normally. When compilers which do not emit large
15572 quantities of duplicate debug information are more common,
15573 this code can probably be removed. */
15575 /* Any complete simple types at the top level (pretty much all
15576 of them, for a language without namespaces), can be processed
15578 if (parent_die
== NULL
15579 && part_die
->has_specification
== 0
15580 && part_die
->is_declaration
== 0
15581 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
15582 || part_die
->tag
== DW_TAG_base_type
15583 || part_die
->tag
== DW_TAG_subrange_type
))
15585 if (building_psymtab
&& part_die
->name
!= NULL
)
15586 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15587 VAR_DOMAIN
, LOC_TYPEDEF
,
15588 &objfile
->static_psymbols
,
15589 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15590 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15594 /* The exception for DW_TAG_typedef with has_children above is
15595 a workaround of GCC PR debug/47510. In the case of this complaint
15596 type_name_no_tag_or_error will error on such types later.
15598 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15599 it could not find the child DIEs referenced later, this is checked
15600 above. In correct DWARF DW_TAG_typedef should have no children. */
15602 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
15603 complaint (&symfile_complaints
,
15604 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15605 "- DIE at 0x%x [in module %s]"),
15606 part_die
->offset
.sect_off
, objfile_name (objfile
));
15608 /* If we're at the second level, and we're an enumerator, and
15609 our parent has no specification (meaning possibly lives in a
15610 namespace elsewhere), then we can add the partial symbol now
15611 instead of queueing it. */
15612 if (part_die
->tag
== DW_TAG_enumerator
15613 && parent_die
!= NULL
15614 && parent_die
->die_parent
== NULL
15615 && parent_die
->tag
== DW_TAG_enumeration_type
15616 && parent_die
->has_specification
== 0)
15618 if (part_die
->name
== NULL
)
15619 complaint (&symfile_complaints
,
15620 _("malformed enumerator DIE ignored"));
15621 else if (building_psymtab
)
15622 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15623 VAR_DOMAIN
, LOC_CONST
,
15624 (cu
->language
== language_cplus
15625 || cu
->language
== language_java
)
15626 ? &objfile
->global_psymbols
15627 : &objfile
->static_psymbols
,
15628 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15630 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15634 /* We'll save this DIE so link it in. */
15635 part_die
->die_parent
= parent_die
;
15636 part_die
->die_sibling
= NULL
;
15637 part_die
->die_child
= NULL
;
15639 if (last_die
&& last_die
== parent_die
)
15640 last_die
->die_child
= part_die
;
15642 last_die
->die_sibling
= part_die
;
15644 last_die
= part_die
;
15646 if (first_die
== NULL
)
15647 first_die
= part_die
;
15649 /* Maybe add the DIE to the hash table. Not all DIEs that we
15650 find interesting need to be in the hash table, because we
15651 also have the parent/sibling/child chains; only those that we
15652 might refer to by offset later during partial symbol reading.
15654 For now this means things that might have be the target of a
15655 DW_AT_specification, DW_AT_abstract_origin, or
15656 DW_AT_extension. DW_AT_extension will refer only to
15657 namespaces; DW_AT_abstract_origin refers to functions (and
15658 many things under the function DIE, but we do not recurse
15659 into function DIEs during partial symbol reading) and
15660 possibly variables as well; DW_AT_specification refers to
15661 declarations. Declarations ought to have the DW_AT_declaration
15662 flag. It happens that GCC forgets to put it in sometimes, but
15663 only for functions, not for types.
15665 Adding more things than necessary to the hash table is harmless
15666 except for the performance cost. Adding too few will result in
15667 wasted time in find_partial_die, when we reread the compilation
15668 unit with load_all_dies set. */
15671 || abbrev
->tag
== DW_TAG_constant
15672 || abbrev
->tag
== DW_TAG_subprogram
15673 || abbrev
->tag
== DW_TAG_variable
15674 || abbrev
->tag
== DW_TAG_namespace
15675 || part_die
->is_declaration
)
15679 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
15680 part_die
->offset
.sect_off
, INSERT
);
15684 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15685 sizeof (struct partial_die_info
));
15687 /* For some DIEs we want to follow their children (if any). For C
15688 we have no reason to follow the children of structures; for other
15689 languages we have to, so that we can get at method physnames
15690 to infer fully qualified class names, for DW_AT_specification,
15691 and for C++ template arguments. For C++, we also look one level
15692 inside functions to find template arguments (if the name of the
15693 function does not already contain the template arguments).
15695 For Ada, we need to scan the children of subprograms and lexical
15696 blocks as well because Ada allows the definition of nested
15697 entities that could be interesting for the debugger, such as
15698 nested subprograms for instance. */
15699 if (last_die
->has_children
15701 || last_die
->tag
== DW_TAG_namespace
15702 || last_die
->tag
== DW_TAG_module
15703 || last_die
->tag
== DW_TAG_enumeration_type
15704 || (cu
->language
== language_cplus
15705 && last_die
->tag
== DW_TAG_subprogram
15706 && (last_die
->name
== NULL
15707 || strchr (last_die
->name
, '<') == NULL
))
15708 || (cu
->language
!= language_c
15709 && (last_die
->tag
== DW_TAG_class_type
15710 || last_die
->tag
== DW_TAG_interface_type
15711 || last_die
->tag
== DW_TAG_structure_type
15712 || last_die
->tag
== DW_TAG_union_type
))
15713 || (cu
->language
== language_ada
15714 && (last_die
->tag
== DW_TAG_subprogram
15715 || last_die
->tag
== DW_TAG_lexical_block
))))
15718 parent_die
= last_die
;
15722 /* Otherwise we skip to the next sibling, if any. */
15723 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
15725 /* Back to the top, do it again. */
15729 /* Read a minimal amount of information into the minimal die structure. */
15731 static const gdb_byte
*
15732 read_partial_die (const struct die_reader_specs
*reader
,
15733 struct partial_die_info
*part_die
,
15734 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
15735 const gdb_byte
*info_ptr
)
15737 struct dwarf2_cu
*cu
= reader
->cu
;
15738 struct objfile
*objfile
= cu
->objfile
;
15739 const gdb_byte
*buffer
= reader
->buffer
;
15741 struct attribute attr
;
15742 int has_low_pc_attr
= 0;
15743 int has_high_pc_attr
= 0;
15744 int high_pc_relative
= 0;
15746 memset (part_die
, 0, sizeof (struct partial_die_info
));
15748 part_die
->offset
.sect_off
= info_ptr
- buffer
;
15750 info_ptr
+= abbrev_len
;
15752 if (abbrev
== NULL
)
15755 part_die
->tag
= abbrev
->tag
;
15756 part_die
->has_children
= abbrev
->has_children
;
15758 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15760 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
15762 /* Store the data if it is of an attribute we want to keep in a
15763 partial symbol table. */
15767 switch (part_die
->tag
)
15769 case DW_TAG_compile_unit
:
15770 case DW_TAG_partial_unit
:
15771 case DW_TAG_type_unit
:
15772 /* Compilation units have a DW_AT_name that is a filename, not
15773 a source language identifier. */
15774 case DW_TAG_enumeration_type
:
15775 case DW_TAG_enumerator
:
15776 /* These tags always have simple identifiers already; no need
15777 to canonicalize them. */
15778 part_die
->name
= DW_STRING (&attr
);
15782 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
15783 &objfile
->per_bfd
->storage_obstack
);
15787 case DW_AT_linkage_name
:
15788 case DW_AT_MIPS_linkage_name
:
15789 /* Note that both forms of linkage name might appear. We
15790 assume they will be the same, and we only store the last
15792 if (cu
->language
== language_ada
)
15793 part_die
->name
= DW_STRING (&attr
);
15794 part_die
->linkage_name
= DW_STRING (&attr
);
15797 has_low_pc_attr
= 1;
15798 part_die
->lowpc
= attr_value_as_address (&attr
);
15800 case DW_AT_high_pc
:
15801 has_high_pc_attr
= 1;
15802 part_die
->highpc
= attr_value_as_address (&attr
);
15803 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
15804 high_pc_relative
= 1;
15806 case DW_AT_location
:
15807 /* Support the .debug_loc offsets. */
15808 if (attr_form_is_block (&attr
))
15810 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
15812 else if (attr_form_is_section_offset (&attr
))
15814 dwarf2_complex_location_expr_complaint ();
15818 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15819 "partial symbol information");
15822 case DW_AT_external
:
15823 part_die
->is_external
= DW_UNSND (&attr
);
15825 case DW_AT_declaration
:
15826 part_die
->is_declaration
= DW_UNSND (&attr
);
15829 part_die
->has_type
= 1;
15831 case DW_AT_abstract_origin
:
15832 case DW_AT_specification
:
15833 case DW_AT_extension
:
15834 part_die
->has_specification
= 1;
15835 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
15836 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15837 || cu
->per_cu
->is_dwz
);
15839 case DW_AT_sibling
:
15840 /* Ignore absolute siblings, they might point outside of
15841 the current compile unit. */
15842 if (attr
.form
== DW_FORM_ref_addr
)
15843 complaint (&symfile_complaints
,
15844 _("ignoring absolute DW_AT_sibling"));
15847 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
15848 const gdb_byte
*sibling_ptr
= buffer
+ off
;
15850 if (sibling_ptr
< info_ptr
)
15851 complaint (&symfile_complaints
,
15852 _("DW_AT_sibling points backwards"));
15853 else if (sibling_ptr
> reader
->buffer_end
)
15854 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
15856 part_die
->sibling
= sibling_ptr
;
15859 case DW_AT_byte_size
:
15860 part_die
->has_byte_size
= 1;
15862 case DW_AT_const_value
:
15863 part_die
->has_const_value
= 1;
15865 case DW_AT_calling_convention
:
15866 /* DWARF doesn't provide a way to identify a program's source-level
15867 entry point. DW_AT_calling_convention attributes are only meant
15868 to describe functions' calling conventions.
15870 However, because it's a necessary piece of information in
15871 Fortran, and because DW_CC_program is the only piece of debugging
15872 information whose definition refers to a 'main program' at all,
15873 several compilers have begun marking Fortran main programs with
15874 DW_CC_program --- even when those functions use the standard
15875 calling conventions.
15877 So until DWARF specifies a way to provide this information and
15878 compilers pick up the new representation, we'll support this
15880 if (DW_UNSND (&attr
) == DW_CC_program
15881 && cu
->language
== language_fortran
)
15882 set_objfile_main_name (objfile
, part_die
->name
, language_fortran
);
15885 if (DW_UNSND (&attr
) == DW_INL_inlined
15886 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
15887 part_die
->may_be_inlined
= 1;
15891 if (part_die
->tag
== DW_TAG_imported_unit
)
15893 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
15894 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15895 || cu
->per_cu
->is_dwz
);
15904 if (high_pc_relative
)
15905 part_die
->highpc
+= part_die
->lowpc
;
15907 if (has_low_pc_attr
&& has_high_pc_attr
)
15909 /* When using the GNU linker, .gnu.linkonce. sections are used to
15910 eliminate duplicate copies of functions and vtables and such.
15911 The linker will arbitrarily choose one and discard the others.
15912 The AT_*_pc values for such functions refer to local labels in
15913 these sections. If the section from that file was discarded, the
15914 labels are not in the output, so the relocs get a value of 0.
15915 If this is a discarded function, mark the pc bounds as invalid,
15916 so that GDB will ignore it. */
15917 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
15919 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15921 complaint (&symfile_complaints
,
15922 _("DW_AT_low_pc %s is zero "
15923 "for DIE at 0x%x [in module %s]"),
15924 paddress (gdbarch
, part_die
->lowpc
),
15925 part_die
->offset
.sect_off
, objfile_name (objfile
));
15927 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15928 else if (part_die
->lowpc
>= part_die
->highpc
)
15930 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15932 complaint (&symfile_complaints
,
15933 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15934 "for DIE at 0x%x [in module %s]"),
15935 paddress (gdbarch
, part_die
->lowpc
),
15936 paddress (gdbarch
, part_die
->highpc
),
15937 part_die
->offset
.sect_off
, objfile_name (objfile
));
15940 part_die
->has_pc_info
= 1;
15946 /* Find a cached partial DIE at OFFSET in CU. */
15948 static struct partial_die_info
*
15949 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
15951 struct partial_die_info
*lookup_die
= NULL
;
15952 struct partial_die_info part_die
;
15954 part_die
.offset
= offset
;
15955 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
15961 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15962 except in the case of .debug_types DIEs which do not reference
15963 outside their CU (they do however referencing other types via
15964 DW_FORM_ref_sig8). */
15966 static struct partial_die_info
*
15967 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
15969 struct objfile
*objfile
= cu
->objfile
;
15970 struct dwarf2_per_cu_data
*per_cu
= NULL
;
15971 struct partial_die_info
*pd
= NULL
;
15973 if (offset_in_dwz
== cu
->per_cu
->is_dwz
15974 && offset_in_cu_p (&cu
->header
, offset
))
15976 pd
= find_partial_die_in_comp_unit (offset
, cu
);
15979 /* We missed recording what we needed.
15980 Load all dies and try again. */
15981 per_cu
= cu
->per_cu
;
15985 /* TUs don't reference other CUs/TUs (except via type signatures). */
15986 if (cu
->per_cu
->is_debug_types
)
15988 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
15989 " external reference to offset 0x%lx [in module %s].\n"),
15990 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
15991 bfd_get_filename (objfile
->obfd
));
15993 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
15996 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
15997 load_partial_comp_unit (per_cu
);
15999 per_cu
->cu
->last_used
= 0;
16000 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16003 /* If we didn't find it, and not all dies have been loaded,
16004 load them all and try again. */
16006 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
16008 per_cu
->load_all_dies
= 1;
16010 /* This is nasty. When we reread the DIEs, somewhere up the call chain
16011 THIS_CU->cu may already be in use. So we can't just free it and
16012 replace its DIEs with the ones we read in. Instead, we leave those
16013 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
16014 and clobber THIS_CU->cu->partial_dies with the hash table for the new
16016 load_partial_comp_unit (per_cu
);
16018 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16022 internal_error (__FILE__
, __LINE__
,
16023 _("could not find partial DIE 0x%x "
16024 "in cache [from module %s]\n"),
16025 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
16029 /* See if we can figure out if the class lives in a namespace. We do
16030 this by looking for a member function; its demangled name will
16031 contain namespace info, if there is any. */
16034 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
16035 struct dwarf2_cu
*cu
)
16037 /* NOTE: carlton/2003-10-07: Getting the info this way changes
16038 what template types look like, because the demangler
16039 frequently doesn't give the same name as the debug info. We
16040 could fix this by only using the demangled name to get the
16041 prefix (but see comment in read_structure_type). */
16043 struct partial_die_info
*real_pdi
;
16044 struct partial_die_info
*child_pdi
;
16046 /* If this DIE (this DIE's specification, if any) has a parent, then
16047 we should not do this. We'll prepend the parent's fully qualified
16048 name when we create the partial symbol. */
16050 real_pdi
= struct_pdi
;
16051 while (real_pdi
->has_specification
)
16052 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
16053 real_pdi
->spec_is_dwz
, cu
);
16055 if (real_pdi
->die_parent
!= NULL
)
16058 for (child_pdi
= struct_pdi
->die_child
;
16060 child_pdi
= child_pdi
->die_sibling
)
16062 if (child_pdi
->tag
== DW_TAG_subprogram
16063 && child_pdi
->linkage_name
!= NULL
)
16065 char *actual_class_name
16066 = language_class_name_from_physname (cu
->language_defn
,
16067 child_pdi
->linkage_name
);
16068 if (actual_class_name
!= NULL
)
16071 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16073 strlen (actual_class_name
));
16074 xfree (actual_class_name
);
16081 /* Adjust PART_DIE before generating a symbol for it. This function
16082 may set the is_external flag or change the DIE's name. */
16085 fixup_partial_die (struct partial_die_info
*part_die
,
16086 struct dwarf2_cu
*cu
)
16088 /* Once we've fixed up a die, there's no point in doing so again.
16089 This also avoids a memory leak if we were to call
16090 guess_partial_die_structure_name multiple times. */
16091 if (part_die
->fixup_called
)
16094 /* If we found a reference attribute and the DIE has no name, try
16095 to find a name in the referred to DIE. */
16097 if (part_die
->name
== NULL
&& part_die
->has_specification
)
16099 struct partial_die_info
*spec_die
;
16101 spec_die
= find_partial_die (part_die
->spec_offset
,
16102 part_die
->spec_is_dwz
, cu
);
16104 fixup_partial_die (spec_die
, cu
);
16106 if (spec_die
->name
)
16108 part_die
->name
= spec_die
->name
;
16110 /* Copy DW_AT_external attribute if it is set. */
16111 if (spec_die
->is_external
)
16112 part_die
->is_external
= spec_die
->is_external
;
16116 /* Set default names for some unnamed DIEs. */
16118 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
16119 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
16121 /* If there is no parent die to provide a namespace, and there are
16122 children, see if we can determine the namespace from their linkage
16124 if (cu
->language
== language_cplus
16125 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
16126 && part_die
->die_parent
== NULL
16127 && part_die
->has_children
16128 && (part_die
->tag
== DW_TAG_class_type
16129 || part_die
->tag
== DW_TAG_structure_type
16130 || part_die
->tag
== DW_TAG_union_type
))
16131 guess_partial_die_structure_name (part_die
, cu
);
16133 /* GCC might emit a nameless struct or union that has a linkage
16134 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16135 if (part_die
->name
== NULL
16136 && (part_die
->tag
== DW_TAG_class_type
16137 || part_die
->tag
== DW_TAG_interface_type
16138 || part_die
->tag
== DW_TAG_structure_type
16139 || part_die
->tag
== DW_TAG_union_type
)
16140 && part_die
->linkage_name
!= NULL
)
16144 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
16149 /* Strip any leading namespaces/classes, keep only the base name.
16150 DW_AT_name for named DIEs does not contain the prefixes. */
16151 base
= strrchr (demangled
, ':');
16152 if (base
&& base
> demangled
&& base
[-1] == ':')
16158 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16159 base
, strlen (base
));
16164 part_die
->fixup_called
= 1;
16167 /* Read an attribute value described by an attribute form. */
16169 static const gdb_byte
*
16170 read_attribute_value (const struct die_reader_specs
*reader
,
16171 struct attribute
*attr
, unsigned form
,
16172 const gdb_byte
*info_ptr
)
16174 struct dwarf2_cu
*cu
= reader
->cu
;
16175 struct objfile
*objfile
= cu
->objfile
;
16176 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16177 bfd
*abfd
= reader
->abfd
;
16178 struct comp_unit_head
*cu_header
= &cu
->header
;
16179 unsigned int bytes_read
;
16180 struct dwarf_block
*blk
;
16185 case DW_FORM_ref_addr
:
16186 if (cu
->header
.version
== 2)
16187 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16189 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
16190 &cu
->header
, &bytes_read
);
16191 info_ptr
+= bytes_read
;
16193 case DW_FORM_GNU_ref_alt
:
16194 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16195 info_ptr
+= bytes_read
;
16198 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16199 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
16200 info_ptr
+= bytes_read
;
16202 case DW_FORM_block2
:
16203 blk
= dwarf_alloc_block (cu
);
16204 blk
->size
= read_2_bytes (abfd
, info_ptr
);
16206 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16207 info_ptr
+= blk
->size
;
16208 DW_BLOCK (attr
) = blk
;
16210 case DW_FORM_block4
:
16211 blk
= dwarf_alloc_block (cu
);
16212 blk
->size
= read_4_bytes (abfd
, info_ptr
);
16214 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16215 info_ptr
+= blk
->size
;
16216 DW_BLOCK (attr
) = blk
;
16218 case DW_FORM_data2
:
16219 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
16222 case DW_FORM_data4
:
16223 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
16226 case DW_FORM_data8
:
16227 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
16230 case DW_FORM_sec_offset
:
16231 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16232 info_ptr
+= bytes_read
;
16234 case DW_FORM_string
:
16235 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
16236 DW_STRING_IS_CANONICAL (attr
) = 0;
16237 info_ptr
+= bytes_read
;
16240 if (!cu
->per_cu
->is_dwz
)
16242 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
16244 DW_STRING_IS_CANONICAL (attr
) = 0;
16245 info_ptr
+= bytes_read
;
16249 case DW_FORM_GNU_strp_alt
:
16251 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
16252 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
16255 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
16256 DW_STRING_IS_CANONICAL (attr
) = 0;
16257 info_ptr
+= bytes_read
;
16260 case DW_FORM_exprloc
:
16261 case DW_FORM_block
:
16262 blk
= dwarf_alloc_block (cu
);
16263 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16264 info_ptr
+= bytes_read
;
16265 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16266 info_ptr
+= blk
->size
;
16267 DW_BLOCK (attr
) = blk
;
16269 case DW_FORM_block1
:
16270 blk
= dwarf_alloc_block (cu
);
16271 blk
->size
= read_1_byte (abfd
, info_ptr
);
16273 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16274 info_ptr
+= blk
->size
;
16275 DW_BLOCK (attr
) = blk
;
16277 case DW_FORM_data1
:
16278 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16282 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16285 case DW_FORM_flag_present
:
16286 DW_UNSND (attr
) = 1;
16288 case DW_FORM_sdata
:
16289 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
16290 info_ptr
+= bytes_read
;
16292 case DW_FORM_udata
:
16293 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16294 info_ptr
+= bytes_read
;
16297 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16298 + read_1_byte (abfd
, info_ptr
));
16302 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16303 + read_2_bytes (abfd
, info_ptr
));
16307 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16308 + read_4_bytes (abfd
, info_ptr
));
16312 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16313 + read_8_bytes (abfd
, info_ptr
));
16316 case DW_FORM_ref_sig8
:
16317 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
16320 case DW_FORM_ref_udata
:
16321 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16322 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
16323 info_ptr
+= bytes_read
;
16325 case DW_FORM_indirect
:
16326 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16327 info_ptr
+= bytes_read
;
16328 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
16330 case DW_FORM_GNU_addr_index
:
16331 if (reader
->dwo_file
== NULL
)
16333 /* For now flag a hard error.
16334 Later we can turn this into a complaint. */
16335 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16336 dwarf_form_name (form
),
16337 bfd_get_filename (abfd
));
16339 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
16340 info_ptr
+= bytes_read
;
16342 case DW_FORM_GNU_str_index
:
16343 if (reader
->dwo_file
== NULL
)
16345 /* For now flag a hard error.
16346 Later we can turn this into a complaint if warranted. */
16347 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16348 dwarf_form_name (form
),
16349 bfd_get_filename (abfd
));
16352 ULONGEST str_index
=
16353 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16355 DW_STRING (attr
) = read_str_index (reader
, str_index
);
16356 DW_STRING_IS_CANONICAL (attr
) = 0;
16357 info_ptr
+= bytes_read
;
16361 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16362 dwarf_form_name (form
),
16363 bfd_get_filename (abfd
));
16367 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
16368 attr
->form
= DW_FORM_GNU_ref_alt
;
16370 /* We have seen instances where the compiler tried to emit a byte
16371 size attribute of -1 which ended up being encoded as an unsigned
16372 0xffffffff. Although 0xffffffff is technically a valid size value,
16373 an object of this size seems pretty unlikely so we can relatively
16374 safely treat these cases as if the size attribute was invalid and
16375 treat them as zero by default. */
16376 if (attr
->name
== DW_AT_byte_size
16377 && form
== DW_FORM_data4
16378 && DW_UNSND (attr
) >= 0xffffffff)
16381 (&symfile_complaints
,
16382 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16383 hex_string (DW_UNSND (attr
)));
16384 DW_UNSND (attr
) = 0;
16390 /* Read an attribute described by an abbreviated attribute. */
16392 static const gdb_byte
*
16393 read_attribute (const struct die_reader_specs
*reader
,
16394 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
16395 const gdb_byte
*info_ptr
)
16397 attr
->name
= abbrev
->name
;
16398 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
16401 /* Read dwarf information from a buffer. */
16403 static unsigned int
16404 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
16406 return bfd_get_8 (abfd
, buf
);
16410 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
16412 return bfd_get_signed_8 (abfd
, buf
);
16415 static unsigned int
16416 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16418 return bfd_get_16 (abfd
, buf
);
16422 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16424 return bfd_get_signed_16 (abfd
, buf
);
16427 static unsigned int
16428 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16430 return bfd_get_32 (abfd
, buf
);
16434 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16436 return bfd_get_signed_32 (abfd
, buf
);
16440 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16442 return bfd_get_64 (abfd
, buf
);
16446 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
16447 unsigned int *bytes_read
)
16449 struct comp_unit_head
*cu_header
= &cu
->header
;
16450 CORE_ADDR retval
= 0;
16452 if (cu_header
->signed_addr_p
)
16454 switch (cu_header
->addr_size
)
16457 retval
= bfd_get_signed_16 (abfd
, buf
);
16460 retval
= bfd_get_signed_32 (abfd
, buf
);
16463 retval
= bfd_get_signed_64 (abfd
, buf
);
16466 internal_error (__FILE__
, __LINE__
,
16467 _("read_address: bad switch, signed [in module %s]"),
16468 bfd_get_filename (abfd
));
16473 switch (cu_header
->addr_size
)
16476 retval
= bfd_get_16 (abfd
, buf
);
16479 retval
= bfd_get_32 (abfd
, buf
);
16482 retval
= bfd_get_64 (abfd
, buf
);
16485 internal_error (__FILE__
, __LINE__
,
16486 _("read_address: bad switch, "
16487 "unsigned [in module %s]"),
16488 bfd_get_filename (abfd
));
16492 *bytes_read
= cu_header
->addr_size
;
16496 /* Read the initial length from a section. The (draft) DWARF 3
16497 specification allows the initial length to take up either 4 bytes
16498 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16499 bytes describe the length and all offsets will be 8 bytes in length
16502 An older, non-standard 64-bit format is also handled by this
16503 function. The older format in question stores the initial length
16504 as an 8-byte quantity without an escape value. Lengths greater
16505 than 2^32 aren't very common which means that the initial 4 bytes
16506 is almost always zero. Since a length value of zero doesn't make
16507 sense for the 32-bit format, this initial zero can be considered to
16508 be an escape value which indicates the presence of the older 64-bit
16509 format. As written, the code can't detect (old format) lengths
16510 greater than 4GB. If it becomes necessary to handle lengths
16511 somewhat larger than 4GB, we could allow other small values (such
16512 as the non-sensical values of 1, 2, and 3) to also be used as
16513 escape values indicating the presence of the old format.
16515 The value returned via bytes_read should be used to increment the
16516 relevant pointer after calling read_initial_length().
16518 [ Note: read_initial_length() and read_offset() are based on the
16519 document entitled "DWARF Debugging Information Format", revision
16520 3, draft 8, dated November 19, 2001. This document was obtained
16523 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16525 This document is only a draft and is subject to change. (So beware.)
16527 Details regarding the older, non-standard 64-bit format were
16528 determined empirically by examining 64-bit ELF files produced by
16529 the SGI toolchain on an IRIX 6.5 machine.
16531 - Kevin, July 16, 2002
16535 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
16537 LONGEST length
= bfd_get_32 (abfd
, buf
);
16539 if (length
== 0xffffffff)
16541 length
= bfd_get_64 (abfd
, buf
+ 4);
16544 else if (length
== 0)
16546 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16547 length
= bfd_get_64 (abfd
, buf
);
16558 /* Cover function for read_initial_length.
16559 Returns the length of the object at BUF, and stores the size of the
16560 initial length in *BYTES_READ and stores the size that offsets will be in
16562 If the initial length size is not equivalent to that specified in
16563 CU_HEADER then issue a complaint.
16564 This is useful when reading non-comp-unit headers. */
16567 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
16568 const struct comp_unit_head
*cu_header
,
16569 unsigned int *bytes_read
,
16570 unsigned int *offset_size
)
16572 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
16574 gdb_assert (cu_header
->initial_length_size
== 4
16575 || cu_header
->initial_length_size
== 8
16576 || cu_header
->initial_length_size
== 12);
16578 if (cu_header
->initial_length_size
!= *bytes_read
)
16579 complaint (&symfile_complaints
,
16580 _("intermixed 32-bit and 64-bit DWARF sections"));
16582 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
16586 /* Read an offset from the data stream. The size of the offset is
16587 given by cu_header->offset_size. */
16590 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
16591 const struct comp_unit_head
*cu_header
,
16592 unsigned int *bytes_read
)
16594 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
16596 *bytes_read
= cu_header
->offset_size
;
16600 /* Read an offset from the data stream. */
16603 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
16605 LONGEST retval
= 0;
16607 switch (offset_size
)
16610 retval
= bfd_get_32 (abfd
, buf
);
16613 retval
= bfd_get_64 (abfd
, buf
);
16616 internal_error (__FILE__
, __LINE__
,
16617 _("read_offset_1: bad switch [in module %s]"),
16618 bfd_get_filename (abfd
));
16624 static const gdb_byte
*
16625 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
16627 /* If the size of a host char is 8 bits, we can return a pointer
16628 to the buffer, otherwise we have to copy the data to a buffer
16629 allocated on the temporary obstack. */
16630 gdb_assert (HOST_CHAR_BIT
== 8);
16634 static const char *
16635 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
16636 unsigned int *bytes_read_ptr
)
16638 /* If the size of a host char is 8 bits, we can return a pointer
16639 to the string, otherwise we have to copy the string to a buffer
16640 allocated on the temporary obstack. */
16641 gdb_assert (HOST_CHAR_BIT
== 8);
16644 *bytes_read_ptr
= 1;
16647 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
16648 return (const char *) buf
;
16651 static const char *
16652 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
16654 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
16655 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
16656 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16657 bfd_get_filename (abfd
));
16658 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
16659 error (_("DW_FORM_strp pointing outside of "
16660 ".debug_str section [in module %s]"),
16661 bfd_get_filename (abfd
));
16662 gdb_assert (HOST_CHAR_BIT
== 8);
16663 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
16665 return (const char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
16668 /* Read a string at offset STR_OFFSET in the .debug_str section from
16669 the .dwz file DWZ. Throw an error if the offset is too large. If
16670 the string consists of a single NUL byte, return NULL; otherwise
16671 return a pointer to the string. */
16673 static const char *
16674 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
16676 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
16678 if (dwz
->str
.buffer
== NULL
)
16679 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16680 "section [in module %s]"),
16681 bfd_get_filename (dwz
->dwz_bfd
));
16682 if (str_offset
>= dwz
->str
.size
)
16683 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16684 ".debug_str section [in module %s]"),
16685 bfd_get_filename (dwz
->dwz_bfd
));
16686 gdb_assert (HOST_CHAR_BIT
== 8);
16687 if (dwz
->str
.buffer
[str_offset
] == '\0')
16689 return (const char *) (dwz
->str
.buffer
+ str_offset
);
16692 static const char *
16693 read_indirect_string (bfd
*abfd
, const gdb_byte
*buf
,
16694 const struct comp_unit_head
*cu_header
,
16695 unsigned int *bytes_read_ptr
)
16697 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
16699 return read_indirect_string_at_offset (abfd
, str_offset
);
16703 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16704 unsigned int *bytes_read_ptr
)
16707 unsigned int num_read
;
16709 unsigned char byte
;
16717 byte
= bfd_get_8 (abfd
, buf
);
16720 result
|= ((ULONGEST
) (byte
& 127) << shift
);
16721 if ((byte
& 128) == 0)
16727 *bytes_read_ptr
= num_read
;
16732 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16733 unsigned int *bytes_read_ptr
)
16736 int i
, shift
, num_read
;
16737 unsigned char byte
;
16745 byte
= bfd_get_8 (abfd
, buf
);
16748 result
|= ((LONGEST
) (byte
& 127) << shift
);
16750 if ((byte
& 128) == 0)
16755 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
16756 result
|= -(((LONGEST
) 1) << shift
);
16757 *bytes_read_ptr
= num_read
;
16761 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16762 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16763 ADDR_SIZE is the size of addresses from the CU header. */
16766 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
16768 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16769 bfd
*abfd
= objfile
->obfd
;
16770 const gdb_byte
*info_ptr
;
16772 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
16773 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
16774 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16775 objfile_name (objfile
));
16776 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
16777 error (_("DW_FORM_addr_index pointing outside of "
16778 ".debug_addr section [in module %s]"),
16779 objfile_name (objfile
));
16780 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
16781 + addr_base
+ addr_index
* addr_size
);
16782 if (addr_size
== 4)
16783 return bfd_get_32 (abfd
, info_ptr
);
16785 return bfd_get_64 (abfd
, info_ptr
);
16788 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16791 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
16793 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
16796 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16799 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
16800 unsigned int *bytes_read
)
16802 bfd
*abfd
= cu
->objfile
->obfd
;
16803 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
16805 return read_addr_index (cu
, addr_index
);
16808 /* Data structure to pass results from dwarf2_read_addr_index_reader
16809 back to dwarf2_read_addr_index. */
16811 struct dwarf2_read_addr_index_data
16813 ULONGEST addr_base
;
16817 /* die_reader_func for dwarf2_read_addr_index. */
16820 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
16821 const gdb_byte
*info_ptr
,
16822 struct die_info
*comp_unit_die
,
16826 struct dwarf2_cu
*cu
= reader
->cu
;
16827 struct dwarf2_read_addr_index_data
*aidata
=
16828 (struct dwarf2_read_addr_index_data
*) data
;
16830 aidata
->addr_base
= cu
->addr_base
;
16831 aidata
->addr_size
= cu
->header
.addr_size
;
16834 /* Given an index in .debug_addr, fetch the value.
16835 NOTE: This can be called during dwarf expression evaluation,
16836 long after the debug information has been read, and thus per_cu->cu
16837 may no longer exist. */
16840 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
16841 unsigned int addr_index
)
16843 struct objfile
*objfile
= per_cu
->objfile
;
16844 struct dwarf2_cu
*cu
= per_cu
->cu
;
16845 ULONGEST addr_base
;
16848 /* This is intended to be called from outside this file. */
16849 dw2_setup (objfile
);
16851 /* We need addr_base and addr_size.
16852 If we don't have PER_CU->cu, we have to get it.
16853 Nasty, but the alternative is storing the needed info in PER_CU,
16854 which at this point doesn't seem justified: it's not clear how frequently
16855 it would get used and it would increase the size of every PER_CU.
16856 Entry points like dwarf2_per_cu_addr_size do a similar thing
16857 so we're not in uncharted territory here.
16858 Alas we need to be a bit more complicated as addr_base is contained
16861 We don't need to read the entire CU(/TU).
16862 We just need the header and top level die.
16864 IWBN to use the aging mechanism to let us lazily later discard the CU.
16865 For now we skip this optimization. */
16869 addr_base
= cu
->addr_base
;
16870 addr_size
= cu
->header
.addr_size
;
16874 struct dwarf2_read_addr_index_data aidata
;
16876 /* Note: We can't use init_cutu_and_read_dies_simple here,
16877 we need addr_base. */
16878 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
16879 dwarf2_read_addr_index_reader
, &aidata
);
16880 addr_base
= aidata
.addr_base
;
16881 addr_size
= aidata
.addr_size
;
16884 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
16887 /* Given a DW_FORM_GNU_str_index, fetch the string.
16888 This is only used by the Fission support. */
16890 static const char *
16891 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
16893 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16894 const char *objf_name
= objfile_name (objfile
);
16895 bfd
*abfd
= objfile
->obfd
;
16896 struct dwarf2_cu
*cu
= reader
->cu
;
16897 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
16898 struct dwarf2_section_info
*str_offsets_section
=
16899 &reader
->dwo_file
->sections
.str_offsets
;
16900 const gdb_byte
*info_ptr
;
16901 ULONGEST str_offset
;
16902 static const char form_name
[] = "DW_FORM_GNU_str_index";
16904 dwarf2_read_section (objfile
, str_section
);
16905 dwarf2_read_section (objfile
, str_offsets_section
);
16906 if (str_section
->buffer
== NULL
)
16907 error (_("%s used without .debug_str.dwo section"
16908 " in CU at offset 0x%lx [in module %s]"),
16909 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16910 if (str_offsets_section
->buffer
== NULL
)
16911 error (_("%s used without .debug_str_offsets.dwo section"
16912 " in CU at offset 0x%lx [in module %s]"),
16913 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16914 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
16915 error (_("%s pointing outside of .debug_str_offsets.dwo"
16916 " section in CU at offset 0x%lx [in module %s]"),
16917 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16918 info_ptr
= (str_offsets_section
->buffer
16919 + str_index
* cu
->header
.offset_size
);
16920 if (cu
->header
.offset_size
== 4)
16921 str_offset
= bfd_get_32 (abfd
, info_ptr
);
16923 str_offset
= bfd_get_64 (abfd
, info_ptr
);
16924 if (str_offset
>= str_section
->size
)
16925 error (_("Offset from %s pointing outside of"
16926 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16927 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16928 return (const char *) (str_section
->buffer
+ str_offset
);
16931 /* Return the length of an LEB128 number in BUF. */
16934 leb128_size (const gdb_byte
*buf
)
16936 const gdb_byte
*begin
= buf
;
16942 if ((byte
& 128) == 0)
16943 return buf
- begin
;
16948 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
16957 cu
->language
= language_c
;
16959 case DW_LANG_C_plus_plus
:
16960 case DW_LANG_C_plus_plus_11
:
16961 case DW_LANG_C_plus_plus_14
:
16962 cu
->language
= language_cplus
;
16965 cu
->language
= language_d
;
16967 case DW_LANG_Fortran77
:
16968 case DW_LANG_Fortran90
:
16969 case DW_LANG_Fortran95
:
16970 case DW_LANG_Fortran03
:
16971 case DW_LANG_Fortran08
:
16972 cu
->language
= language_fortran
;
16975 cu
->language
= language_go
;
16977 case DW_LANG_Mips_Assembler
:
16978 cu
->language
= language_asm
;
16981 cu
->language
= language_java
;
16983 case DW_LANG_Ada83
:
16984 case DW_LANG_Ada95
:
16985 cu
->language
= language_ada
;
16987 case DW_LANG_Modula2
:
16988 cu
->language
= language_m2
;
16990 case DW_LANG_Pascal83
:
16991 cu
->language
= language_pascal
;
16994 cu
->language
= language_objc
;
16996 case DW_LANG_Cobol74
:
16997 case DW_LANG_Cobol85
:
16999 cu
->language
= language_minimal
;
17002 cu
->language_defn
= language_def (cu
->language
);
17005 /* Return the named attribute or NULL if not there. */
17007 static struct attribute
*
17008 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
17013 struct attribute
*spec
= NULL
;
17015 for (i
= 0; i
< die
->num_attrs
; ++i
)
17017 if (die
->attrs
[i
].name
== name
)
17018 return &die
->attrs
[i
];
17019 if (die
->attrs
[i
].name
== DW_AT_specification
17020 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
17021 spec
= &die
->attrs
[i
];
17027 die
= follow_die_ref (die
, spec
, &cu
);
17033 /* Return the named attribute or NULL if not there,
17034 but do not follow DW_AT_specification, etc.
17035 This is for use in contexts where we're reading .debug_types dies.
17036 Following DW_AT_specification, DW_AT_abstract_origin will take us
17037 back up the chain, and we want to go down. */
17039 static struct attribute
*
17040 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
17044 for (i
= 0; i
< die
->num_attrs
; ++i
)
17045 if (die
->attrs
[i
].name
== name
)
17046 return &die
->attrs
[i
];
17051 /* Return non-zero iff the attribute NAME is defined for the given DIE,
17052 and holds a non-zero value. This function should only be used for
17053 DW_FORM_flag or DW_FORM_flag_present attributes. */
17056 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
17058 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
17060 return (attr
&& DW_UNSND (attr
));
17064 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
17066 /* A DIE is a declaration if it has a DW_AT_declaration attribute
17067 which value is non-zero. However, we have to be careful with
17068 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
17069 (via dwarf2_flag_true_p) follows this attribute. So we may
17070 end up accidently finding a declaration attribute that belongs
17071 to a different DIE referenced by the specification attribute,
17072 even though the given DIE does not have a declaration attribute. */
17073 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
17074 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
17077 /* Return the die giving the specification for DIE, if there is
17078 one. *SPEC_CU is the CU containing DIE on input, and the CU
17079 containing the return value on output. If there is no
17080 specification, but there is an abstract origin, that is
17083 static struct die_info
*
17084 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
17086 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
17089 if (spec_attr
== NULL
)
17090 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
17092 if (spec_attr
== NULL
)
17095 return follow_die_ref (die
, spec_attr
, spec_cu
);
17098 /* Free the line_header structure *LH, and any arrays and strings it
17100 NOTE: This is also used as a "cleanup" function. */
17103 free_line_header (struct line_header
*lh
)
17105 if (lh
->standard_opcode_lengths
)
17106 xfree (lh
->standard_opcode_lengths
);
17108 /* Remember that all the lh->file_names[i].name pointers are
17109 pointers into debug_line_buffer, and don't need to be freed. */
17110 if (lh
->file_names
)
17111 xfree (lh
->file_names
);
17113 /* Similarly for the include directory names. */
17114 if (lh
->include_dirs
)
17115 xfree (lh
->include_dirs
);
17120 /* Stub for free_line_header to match void * callback types. */
17123 free_line_header_voidp (void *arg
)
17125 struct line_header
*lh
= arg
;
17127 free_line_header (lh
);
17130 /* Add an entry to LH's include directory table. */
17133 add_include_dir (struct line_header
*lh
, const char *include_dir
)
17135 /* Grow the array if necessary. */
17136 if (lh
->include_dirs_size
== 0)
17138 lh
->include_dirs_size
= 1; /* for testing */
17139 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
17140 * sizeof (*lh
->include_dirs
));
17142 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
17144 lh
->include_dirs_size
*= 2;
17145 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
17146 (lh
->include_dirs_size
17147 * sizeof (*lh
->include_dirs
)));
17150 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
17153 /* Add an entry to LH's file name table. */
17156 add_file_name (struct line_header
*lh
,
17158 unsigned int dir_index
,
17159 unsigned int mod_time
,
17160 unsigned int length
)
17162 struct file_entry
*fe
;
17164 /* Grow the array if necessary. */
17165 if (lh
->file_names_size
== 0)
17167 lh
->file_names_size
= 1; /* for testing */
17168 lh
->file_names
= xmalloc (lh
->file_names_size
17169 * sizeof (*lh
->file_names
));
17171 else if (lh
->num_file_names
>= lh
->file_names_size
)
17173 lh
->file_names_size
*= 2;
17174 lh
->file_names
= xrealloc (lh
->file_names
,
17175 (lh
->file_names_size
17176 * sizeof (*lh
->file_names
)));
17179 fe
= &lh
->file_names
[lh
->num_file_names
++];
17181 fe
->dir_index
= dir_index
;
17182 fe
->mod_time
= mod_time
;
17183 fe
->length
= length
;
17184 fe
->included_p
= 0;
17188 /* A convenience function to find the proper .debug_line section for a
17191 static struct dwarf2_section_info
*
17192 get_debug_line_section (struct dwarf2_cu
*cu
)
17194 struct dwarf2_section_info
*section
;
17196 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
17198 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17199 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
17200 else if (cu
->per_cu
->is_dwz
)
17202 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17204 section
= &dwz
->line
;
17207 section
= &dwarf2_per_objfile
->line
;
17212 /* Read the statement program header starting at OFFSET in
17213 .debug_line, or .debug_line.dwo. Return a pointer
17214 to a struct line_header, allocated using xmalloc.
17215 Returns NULL if there is a problem reading the header, e.g., if it
17216 has a version we don't understand.
17218 NOTE: the strings in the include directory and file name tables of
17219 the returned object point into the dwarf line section buffer,
17220 and must not be freed. */
17222 static struct line_header
*
17223 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
17225 struct cleanup
*back_to
;
17226 struct line_header
*lh
;
17227 const gdb_byte
*line_ptr
;
17228 unsigned int bytes_read
, offset_size
;
17230 const char *cur_dir
, *cur_file
;
17231 struct dwarf2_section_info
*section
;
17234 section
= get_debug_line_section (cu
);
17235 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
17236 if (section
->buffer
== NULL
)
17238 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17239 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
17241 complaint (&symfile_complaints
, _("missing .debug_line section"));
17245 /* We can't do this until we know the section is non-empty.
17246 Only then do we know we have such a section. */
17247 abfd
= get_section_bfd_owner (section
);
17249 /* Make sure that at least there's room for the total_length field.
17250 That could be 12 bytes long, but we're just going to fudge that. */
17251 if (offset
+ 4 >= section
->size
)
17253 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17257 lh
= xmalloc (sizeof (*lh
));
17258 memset (lh
, 0, sizeof (*lh
));
17259 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
17262 lh
->offset
.sect_off
= offset
;
17263 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
17265 line_ptr
= section
->buffer
+ offset
;
17267 /* Read in the header. */
17269 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
17270 &bytes_read
, &offset_size
);
17271 line_ptr
+= bytes_read
;
17272 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
17274 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17275 do_cleanups (back_to
);
17278 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
17279 lh
->version
= read_2_bytes (abfd
, line_ptr
);
17281 if (lh
->version
> 4)
17283 /* This is a version we don't understand. The format could have
17284 changed in ways we don't handle properly so just punt. */
17285 complaint (&symfile_complaints
,
17286 _("unsupported version in .debug_line section"));
17289 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
17290 line_ptr
+= offset_size
;
17291 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
17293 if (lh
->version
>= 4)
17295 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
17299 lh
->maximum_ops_per_instruction
= 1;
17301 if (lh
->maximum_ops_per_instruction
== 0)
17303 lh
->maximum_ops_per_instruction
= 1;
17304 complaint (&symfile_complaints
,
17305 _("invalid maximum_ops_per_instruction "
17306 "in `.debug_line' section"));
17309 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
17311 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
17313 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
17315 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
17317 lh
->standard_opcode_lengths
17318 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
17320 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
17321 for (i
= 1; i
< lh
->opcode_base
; ++i
)
17323 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
17327 /* Read directory table. */
17328 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17330 line_ptr
+= bytes_read
;
17331 add_include_dir (lh
, cur_dir
);
17333 line_ptr
+= bytes_read
;
17335 /* Read file name table. */
17336 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17338 unsigned int dir_index
, mod_time
, length
;
17340 line_ptr
+= bytes_read
;
17341 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17342 line_ptr
+= bytes_read
;
17343 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17344 line_ptr
+= bytes_read
;
17345 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17346 line_ptr
+= bytes_read
;
17348 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17350 line_ptr
+= bytes_read
;
17351 lh
->statement_program_start
= line_ptr
;
17353 if (line_ptr
> (section
->buffer
+ section
->size
))
17354 complaint (&symfile_complaints
,
17355 _("line number info header doesn't "
17356 "fit in `.debug_line' section"));
17358 discard_cleanups (back_to
);
17362 /* Subroutine of dwarf_decode_lines to simplify it.
17363 Return the file name of the psymtab for included file FILE_INDEX
17364 in line header LH of PST.
17365 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17366 If space for the result is malloc'd, it will be freed by a cleanup.
17367 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17369 The function creates dangling cleanup registration. */
17371 static const char *
17372 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
17373 const struct partial_symtab
*pst
,
17374 const char *comp_dir
)
17376 const struct file_entry fe
= lh
->file_names
[file_index
];
17377 const char *include_name
= fe
.name
;
17378 const char *include_name_to_compare
= include_name
;
17379 const char *dir_name
= NULL
;
17380 const char *pst_filename
;
17381 char *copied_name
= NULL
;
17385 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
17387 if (!IS_ABSOLUTE_PATH (include_name
)
17388 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
17390 /* Avoid creating a duplicate psymtab for PST.
17391 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17392 Before we do the comparison, however, we need to account
17393 for DIR_NAME and COMP_DIR.
17394 First prepend dir_name (if non-NULL). If we still don't
17395 have an absolute path prepend comp_dir (if non-NULL).
17396 However, the directory we record in the include-file's
17397 psymtab does not contain COMP_DIR (to match the
17398 corresponding symtab(s)).
17403 bash$ gcc -g ./hello.c
17404 include_name = "hello.c"
17406 DW_AT_comp_dir = comp_dir = "/tmp"
17407 DW_AT_name = "./hello.c"
17411 if (dir_name
!= NULL
)
17413 char *tem
= concat (dir_name
, SLASH_STRING
,
17414 include_name
, (char *)NULL
);
17416 make_cleanup (xfree
, tem
);
17417 include_name
= tem
;
17418 include_name_to_compare
= include_name
;
17420 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
17422 char *tem
= concat (comp_dir
, SLASH_STRING
,
17423 include_name
, (char *)NULL
);
17425 make_cleanup (xfree
, tem
);
17426 include_name_to_compare
= tem
;
17430 pst_filename
= pst
->filename
;
17431 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
17433 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
17434 pst_filename
, (char *)NULL
);
17435 pst_filename
= copied_name
;
17438 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
17440 if (copied_name
!= NULL
)
17441 xfree (copied_name
);
17445 return include_name
;
17448 /* Ignore this record_line request. */
17451 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17456 /* Return non-zero if we should add LINE to the line number table.
17457 LINE is the line to add, LAST_LINE is the last line that was added,
17458 LAST_SUBFILE is the subfile for LAST_LINE.
17459 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17460 had a non-zero discriminator.
17462 We have to be careful in the presence of discriminators.
17463 E.g., for this line:
17465 for (i = 0; i < 100000; i++);
17467 clang can emit four line number entries for that one line,
17468 each with a different discriminator.
17469 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17471 However, we want gdb to coalesce all four entries into one.
17472 Otherwise the user could stepi into the middle of the line and
17473 gdb would get confused about whether the pc really was in the
17474 middle of the line.
17476 Things are further complicated by the fact that two consecutive
17477 line number entries for the same line is a heuristic used by gcc
17478 to denote the end of the prologue. So we can't just discard duplicate
17479 entries, we have to be selective about it. The heuristic we use is
17480 that we only collapse consecutive entries for the same line if at least
17481 one of those entries has a non-zero discriminator. PR 17276.
17483 Note: Addresses in the line number state machine can never go backwards
17484 within one sequence, thus this coalescing is ok. */
17487 dwarf_record_line_p (unsigned int line
, unsigned int last_line
,
17488 int line_has_non_zero_discriminator
,
17489 struct subfile
*last_subfile
)
17491 if (current_subfile
!= last_subfile
)
17493 if (line
!= last_line
)
17495 /* Same line for the same file that we've seen already.
17496 As a last check, for pr 17276, only record the line if the line
17497 has never had a non-zero discriminator. */
17498 if (!line_has_non_zero_discriminator
)
17503 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17504 in the line table of subfile SUBFILE. */
17507 dwarf_record_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17508 unsigned int line
, CORE_ADDR address
,
17509 record_line_ftype p_record_line
)
17511 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17513 (*p_record_line
) (subfile
, line
, addr
);
17516 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17517 Mark the end of a set of line number records.
17518 The arguments are the same as for dwarf_record_line.
17519 If SUBFILE is NULL the request is ignored. */
17522 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17523 CORE_ADDR address
, record_line_ftype p_record_line
)
17525 if (subfile
!= NULL
)
17526 dwarf_record_line (gdbarch
, subfile
, 0, address
, p_record_line
);
17529 /* Subroutine of dwarf_decode_lines to simplify it.
17530 Process the line number information in LH. */
17533 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
17534 const int decode_for_pst_p
, CORE_ADDR lowpc
)
17536 const gdb_byte
*line_ptr
, *extended_end
;
17537 const gdb_byte
*line_end
;
17538 unsigned int bytes_read
, extended_len
;
17539 unsigned char op_code
, extended_op
;
17540 CORE_ADDR baseaddr
;
17541 struct objfile
*objfile
= cu
->objfile
;
17542 bfd
*abfd
= objfile
->obfd
;
17543 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17544 struct subfile
*last_subfile
= NULL
;
17545 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17548 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17550 line_ptr
= lh
->statement_program_start
;
17551 line_end
= lh
->statement_program_end
;
17553 /* Read the statement sequences until there's nothing left. */
17554 while (line_ptr
< line_end
)
17556 /* State machine registers. Call `gdbarch_adjust_dwarf2_line'
17557 on the initial 0 address as if there was a line entry for it
17558 so that the backend has a chance to adjust it and also record
17559 it in case it needs it. This is currently used by MIPS code,
17560 cf. `mips_adjust_dwarf2_line'. */
17561 CORE_ADDR address
= gdbarch_adjust_dwarf2_line (gdbarch
, 0, 0);
17562 unsigned int file
= 1;
17563 unsigned int line
= 1;
17564 int is_stmt
= lh
->default_is_stmt
;
17565 int end_sequence
= 0;
17566 unsigned char op_index
= 0;
17567 unsigned int discriminator
= 0;
17568 /* The last line number that was recorded, used to coalesce
17569 consecutive entries for the same line. This can happen, for
17570 example, when discriminators are present. PR 17276. */
17571 unsigned int last_line
= 0;
17572 int line_has_non_zero_discriminator
= 0;
17574 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
17576 /* Start a subfile for the current file of the state machine. */
17577 /* lh->include_dirs and lh->file_names are 0-based, but the
17578 directory and file name numbers in the statement program
17580 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
17581 const char *dir
= NULL
;
17584 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17586 dwarf2_start_subfile (fe
->name
, dir
);
17589 /* Decode the table. */
17590 while (!end_sequence
)
17592 op_code
= read_1_byte (abfd
, line_ptr
);
17594 if (line_ptr
> line_end
)
17596 dwarf2_debug_line_missing_end_sequence_complaint ();
17600 if (op_code
>= lh
->opcode_base
)
17602 /* Special opcode. */
17603 unsigned char adj_opcode
;
17604 CORE_ADDR addr_adj
;
17607 adj_opcode
= op_code
- lh
->opcode_base
;
17608 addr_adj
= (((op_index
+ (adj_opcode
/ lh
->line_range
))
17609 / lh
->maximum_ops_per_instruction
)
17610 * lh
->minimum_instruction_length
);
17611 address
+= gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17612 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
17613 % lh
->maximum_ops_per_instruction
);
17614 line_delta
= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
17615 line
+= line_delta
;
17616 if (line_delta
!= 0)
17617 line_has_non_zero_discriminator
= discriminator
!= 0;
17618 if (lh
->num_file_names
< file
|| file
== 0)
17619 dwarf2_debug_line_missing_file_complaint ();
17620 /* For now we ignore lines not starting on an
17621 instruction boundary. */
17622 else if (op_index
== 0)
17624 lh
->file_names
[file
- 1].included_p
= 1;
17625 if (!decode_for_pst_p
&& is_stmt
)
17627 if (last_subfile
!= current_subfile
)
17629 dwarf_finish_line (gdbarch
, last_subfile
,
17630 address
, p_record_line
);
17632 if (dwarf_record_line_p (line
, last_line
,
17633 line_has_non_zero_discriminator
,
17636 dwarf_record_line (gdbarch
, current_subfile
,
17637 line
, address
, p_record_line
);
17639 last_subfile
= current_subfile
;
17645 else switch (op_code
)
17647 case DW_LNS_extended_op
:
17648 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
17650 line_ptr
+= bytes_read
;
17651 extended_end
= line_ptr
+ extended_len
;
17652 extended_op
= read_1_byte (abfd
, line_ptr
);
17654 switch (extended_op
)
17656 case DW_LNE_end_sequence
:
17657 p_record_line
= record_line
;
17660 case DW_LNE_set_address
:
17661 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
17663 /* If address < lowpc then it's not a usable value, it's
17664 outside the pc range of the CU. However, we restrict
17665 the test to only address values of zero to preserve
17666 GDB's previous behaviour which is to handle the specific
17667 case of a function being GC'd by the linker. */
17668 if (address
== 0 && address
< lowpc
)
17670 /* This line table is for a function which has been
17671 GCd by the linker. Ignore it. PR gdb/12528 */
17674 = line_ptr
- get_debug_line_section (cu
)->buffer
;
17676 complaint (&symfile_complaints
,
17677 _(".debug_line address at offset 0x%lx is 0 "
17679 line_offset
, objfile_name (objfile
));
17680 p_record_line
= noop_record_line
;
17681 /* Note: p_record_line is left as noop_record_line
17682 until we see DW_LNE_end_sequence. */
17686 line_ptr
+= bytes_read
;
17687 address
+= baseaddr
;
17688 address
= gdbarch_adjust_dwarf2_line (gdbarch
, address
, 0);
17690 case DW_LNE_define_file
:
17692 const char *cur_file
;
17693 unsigned int dir_index
, mod_time
, length
;
17695 cur_file
= read_direct_string (abfd
, line_ptr
,
17697 line_ptr
+= bytes_read
;
17699 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17700 line_ptr
+= bytes_read
;
17702 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17703 line_ptr
+= bytes_read
;
17705 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17706 line_ptr
+= bytes_read
;
17707 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17710 case DW_LNE_set_discriminator
:
17711 /* The discriminator is not interesting to the debugger;
17712 just ignore it. We still need to check its value though:
17713 if there are consecutive entries for the same
17714 (non-prologue) line we want to coalesce them.
17716 discriminator
= read_unsigned_leb128 (abfd
, line_ptr
,
17718 line_has_non_zero_discriminator
|= discriminator
!= 0;
17719 line_ptr
+= bytes_read
;
17722 complaint (&symfile_complaints
,
17723 _("mangled .debug_line section"));
17726 /* Make sure that we parsed the extended op correctly. If e.g.
17727 we expected a different address size than the producer used,
17728 we may have read the wrong number of bytes. */
17729 if (line_ptr
!= extended_end
)
17731 complaint (&symfile_complaints
,
17732 _("mangled .debug_line section"));
17737 if (lh
->num_file_names
< file
|| file
== 0)
17738 dwarf2_debug_line_missing_file_complaint ();
17741 lh
->file_names
[file
- 1].included_p
= 1;
17742 if (!decode_for_pst_p
&& is_stmt
)
17744 if (last_subfile
!= current_subfile
)
17746 dwarf_finish_line (gdbarch
, last_subfile
,
17747 address
, p_record_line
);
17749 if (dwarf_record_line_p (line
, last_line
,
17750 line_has_non_zero_discriminator
,
17753 dwarf_record_line (gdbarch
, current_subfile
,
17754 line
, address
, p_record_line
);
17756 last_subfile
= current_subfile
;
17762 case DW_LNS_advance_pc
:
17765 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17766 CORE_ADDR addr_adj
;
17768 addr_adj
= (((op_index
+ adjust
)
17769 / lh
->maximum_ops_per_instruction
)
17770 * lh
->minimum_instruction_length
);
17771 address
+= gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17772 op_index
= ((op_index
+ adjust
)
17773 % lh
->maximum_ops_per_instruction
);
17774 line_ptr
+= bytes_read
;
17777 case DW_LNS_advance_line
:
17780 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
17782 line
+= line_delta
;
17783 if (line_delta
!= 0)
17784 line_has_non_zero_discriminator
= discriminator
!= 0;
17785 line_ptr
+= bytes_read
;
17788 case DW_LNS_set_file
:
17790 /* The arrays lh->include_dirs and lh->file_names are
17791 0-based, but the directory and file name numbers in
17792 the statement program are 1-based. */
17793 struct file_entry
*fe
;
17794 const char *dir
= NULL
;
17796 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17797 line_ptr
+= bytes_read
;
17798 if (lh
->num_file_names
< file
|| file
== 0)
17799 dwarf2_debug_line_missing_file_complaint ();
17802 fe
= &lh
->file_names
[file
- 1];
17804 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17805 if (!decode_for_pst_p
)
17807 last_subfile
= current_subfile
;
17808 line_has_non_zero_discriminator
= discriminator
!= 0;
17809 dwarf2_start_subfile (fe
->name
, dir
);
17814 case DW_LNS_set_column
:
17815 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17816 line_ptr
+= bytes_read
;
17818 case DW_LNS_negate_stmt
:
17819 is_stmt
= (!is_stmt
);
17821 case DW_LNS_set_basic_block
:
17823 /* Add to the address register of the state machine the
17824 address increment value corresponding to special opcode
17825 255. I.e., this value is scaled by the minimum
17826 instruction length since special opcode 255 would have
17827 scaled the increment. */
17828 case DW_LNS_const_add_pc
:
17830 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
17831 CORE_ADDR addr_adj
;
17833 addr_adj
= (((op_index
+ adjust
)
17834 / lh
->maximum_ops_per_instruction
)
17835 * lh
->minimum_instruction_length
);
17836 address
+= gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17837 op_index
= ((op_index
+ adjust
)
17838 % lh
->maximum_ops_per_instruction
);
17841 case DW_LNS_fixed_advance_pc
:
17843 CORE_ADDR addr_adj
;
17845 addr_adj
= read_2_bytes (abfd
, line_ptr
);
17846 address
+= gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17853 /* Unknown standard opcode, ignore it. */
17856 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
17858 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17859 line_ptr
+= bytes_read
;
17864 if (lh
->num_file_names
< file
|| file
== 0)
17865 dwarf2_debug_line_missing_file_complaint ();
17868 lh
->file_names
[file
- 1].included_p
= 1;
17869 if (!decode_for_pst_p
)
17871 dwarf_finish_line (gdbarch
, current_subfile
, address
,
17878 /* Decode the Line Number Program (LNP) for the given line_header
17879 structure and CU. The actual information extracted and the type
17880 of structures created from the LNP depends on the value of PST.
17882 1. If PST is NULL, then this procedure uses the data from the program
17883 to create all necessary symbol tables, and their linetables.
17885 2. If PST is not NULL, this procedure reads the program to determine
17886 the list of files included by the unit represented by PST, and
17887 builds all the associated partial symbol tables.
17889 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17890 It is used for relative paths in the line table.
17891 NOTE: When processing partial symtabs (pst != NULL),
17892 comp_dir == pst->dirname.
17894 NOTE: It is important that psymtabs have the same file name (via strcmp)
17895 as the corresponding symtab. Since COMP_DIR is not used in the name of the
17896 symtab we don't use it in the name of the psymtabs we create.
17897 E.g. expand_line_sal requires this when finding psymtabs to expand.
17898 A good testcase for this is mb-inline.exp.
17900 LOWPC is the lowest address in CU (or 0 if not known).
17902 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
17903 for its PC<->lines mapping information. Otherwise only the filename
17904 table is read in. */
17907 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
17908 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
17909 CORE_ADDR lowpc
, int decode_mapping
)
17911 struct objfile
*objfile
= cu
->objfile
;
17912 const int decode_for_pst_p
= (pst
!= NULL
);
17914 if (decode_mapping
)
17915 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
17917 if (decode_for_pst_p
)
17921 /* Now that we're done scanning the Line Header Program, we can
17922 create the psymtab of each included file. */
17923 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
17924 if (lh
->file_names
[file_index
].included_p
== 1)
17926 const char *include_name
=
17927 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
17928 if (include_name
!= NULL
)
17929 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
17934 /* Make sure a symtab is created for every file, even files
17935 which contain only variables (i.e. no code with associated
17937 struct compunit_symtab
*cust
= buildsym_compunit_symtab ();
17940 for (i
= 0; i
< lh
->num_file_names
; i
++)
17942 const char *dir
= NULL
;
17943 struct file_entry
*fe
;
17945 fe
= &lh
->file_names
[i
];
17947 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17948 dwarf2_start_subfile (fe
->name
, dir
);
17950 if (current_subfile
->symtab
== NULL
)
17952 current_subfile
->symtab
17953 = allocate_symtab (cust
, current_subfile
->name
);
17955 fe
->symtab
= current_subfile
->symtab
;
17960 /* Start a subfile for DWARF. FILENAME is the name of the file and
17961 DIRNAME the name of the source directory which contains FILENAME
17962 or NULL if not known.
17963 This routine tries to keep line numbers from identical absolute and
17964 relative file names in a common subfile.
17966 Using the `list' example from the GDB testsuite, which resides in
17967 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
17968 of /srcdir/list0.c yields the following debugging information for list0.c:
17970 DW_AT_name: /srcdir/list0.c
17971 DW_AT_comp_dir: /compdir
17972 files.files[0].name: list0.h
17973 files.files[0].dir: /srcdir
17974 files.files[1].name: list0.c
17975 files.files[1].dir: /srcdir
17977 The line number information for list0.c has to end up in a single
17978 subfile, so that `break /srcdir/list0.c:1' works as expected.
17979 start_subfile will ensure that this happens provided that we pass the
17980 concatenation of files.files[1].dir and files.files[1].name as the
17984 dwarf2_start_subfile (const char *filename
, const char *dirname
)
17988 /* In order not to lose the line information directory,
17989 we concatenate it to the filename when it makes sense.
17990 Note that the Dwarf3 standard says (speaking of filenames in line
17991 information): ``The directory index is ignored for file names
17992 that represent full path names''. Thus ignoring dirname in the
17993 `else' branch below isn't an issue. */
17995 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
17997 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
18001 start_subfile (filename
);
18007 /* Start a symtab for DWARF.
18008 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
18010 static struct compunit_symtab
*
18011 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
18012 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
18014 struct compunit_symtab
*cust
18015 = start_symtab (cu
->objfile
, name
, comp_dir
, low_pc
);
18017 record_debugformat ("DWARF 2");
18018 record_producer (cu
->producer
);
18020 /* We assume that we're processing GCC output. */
18021 processing_gcc_compilation
= 2;
18023 cu
->processing_has_namespace_info
= 0;
18029 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
18030 struct dwarf2_cu
*cu
)
18032 struct objfile
*objfile
= cu
->objfile
;
18033 struct comp_unit_head
*cu_header
= &cu
->header
;
18035 /* NOTE drow/2003-01-30: There used to be a comment and some special
18036 code here to turn a symbol with DW_AT_external and a
18037 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
18038 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
18039 with some versions of binutils) where shared libraries could have
18040 relocations against symbols in their debug information - the
18041 minimal symbol would have the right address, but the debug info
18042 would not. It's no longer necessary, because we will explicitly
18043 apply relocations when we read in the debug information now. */
18045 /* A DW_AT_location attribute with no contents indicates that a
18046 variable has been optimized away. */
18047 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
18049 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18053 /* Handle one degenerate form of location expression specially, to
18054 preserve GDB's previous behavior when section offsets are
18055 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
18056 then mark this symbol as LOC_STATIC. */
18058 if (attr_form_is_block (attr
)
18059 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
18060 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
18061 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
18062 && (DW_BLOCK (attr
)->size
18063 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
18065 unsigned int dummy
;
18067 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
18068 SYMBOL_VALUE_ADDRESS (sym
) =
18069 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
18071 SYMBOL_VALUE_ADDRESS (sym
) =
18072 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
18073 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
18074 fixup_symbol_section (sym
, objfile
);
18075 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
18076 SYMBOL_SECTION (sym
));
18080 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
18081 expression evaluator, and use LOC_COMPUTED only when necessary
18082 (i.e. when the value of a register or memory location is
18083 referenced, or a thread-local block, etc.). Then again, it might
18084 not be worthwhile. I'm assuming that it isn't unless performance
18085 or memory numbers show me otherwise. */
18087 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
18089 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
18090 cu
->has_loclist
= 1;
18093 /* Given a pointer to a DWARF information entry, figure out if we need
18094 to make a symbol table entry for it, and if so, create a new entry
18095 and return a pointer to it.
18096 If TYPE is NULL, determine symbol type from the die, otherwise
18097 used the passed type.
18098 If SPACE is not NULL, use it to hold the new symbol. If it is
18099 NULL, allocate a new symbol on the objfile's obstack. */
18101 static struct symbol
*
18102 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
18103 struct symbol
*space
)
18105 struct objfile
*objfile
= cu
->objfile
;
18106 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18107 struct symbol
*sym
= NULL
;
18109 struct attribute
*attr
= NULL
;
18110 struct attribute
*attr2
= NULL
;
18111 CORE_ADDR baseaddr
;
18112 struct pending
**list_to_add
= NULL
;
18114 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
18116 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
18118 name
= dwarf2_name (die
, cu
);
18121 const char *linkagename
;
18122 int suppress_add
= 0;
18127 sym
= allocate_symbol (objfile
);
18128 OBJSTAT (objfile
, n_syms
++);
18130 /* Cache this symbol's name and the name's demangled form (if any). */
18131 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
18132 linkagename
= dwarf2_physname (name
, die
, cu
);
18133 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
18135 /* Fortran does not have mangling standard and the mangling does differ
18136 between gfortran, iFort etc. */
18137 if (cu
->language
== language_fortran
18138 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
18139 symbol_set_demangled_name (&(sym
->ginfo
),
18140 dwarf2_full_name (name
, die
, cu
),
18143 /* Default assumptions.
18144 Use the passed type or decode it from the die. */
18145 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18146 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18148 SYMBOL_TYPE (sym
) = type
;
18150 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
18151 attr
= dwarf2_attr (die
,
18152 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
18156 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
18159 attr
= dwarf2_attr (die
,
18160 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
18164 int file_index
= DW_UNSND (attr
);
18166 if (cu
->line_header
== NULL
18167 || file_index
> cu
->line_header
->num_file_names
)
18168 complaint (&symfile_complaints
,
18169 _("file index out of range"));
18170 else if (file_index
> 0)
18172 struct file_entry
*fe
;
18174 fe
= &cu
->line_header
->file_names
[file_index
- 1];
18175 symbol_set_symtab (sym
, fe
->symtab
);
18182 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
18187 addr
= attr_value_as_address (attr
);
18188 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
18189 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
18191 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
18192 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
18193 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
18194 add_symbol_to_list (sym
, cu
->list_in_scope
);
18196 case DW_TAG_subprogram
:
18197 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18199 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18200 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18201 if ((attr2
&& (DW_UNSND (attr2
) != 0))
18202 || cu
->language
== language_ada
)
18204 /* Subprograms marked external are stored as a global symbol.
18205 Ada subprograms, whether marked external or not, are always
18206 stored as a global symbol, because we want to be able to
18207 access them globally. For instance, we want to be able
18208 to break on a nested subprogram without having to
18209 specify the context. */
18210 list_to_add
= &global_symbols
;
18214 list_to_add
= cu
->list_in_scope
;
18217 case DW_TAG_inlined_subroutine
:
18218 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18220 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18221 SYMBOL_INLINED (sym
) = 1;
18222 list_to_add
= cu
->list_in_scope
;
18224 case DW_TAG_template_value_param
:
18226 /* Fall through. */
18227 case DW_TAG_constant
:
18228 case DW_TAG_variable
:
18229 case DW_TAG_member
:
18230 /* Compilation with minimal debug info may result in
18231 variables with missing type entries. Change the
18232 misleading `void' type to something sensible. */
18233 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
18235 = objfile_type (objfile
)->nodebug_data_symbol
;
18237 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18238 /* In the case of DW_TAG_member, we should only be called for
18239 static const members. */
18240 if (die
->tag
== DW_TAG_member
)
18242 /* dwarf2_add_field uses die_is_declaration,
18243 so we do the same. */
18244 gdb_assert (die_is_declaration (die
, cu
));
18249 dwarf2_const_value (attr
, sym
, cu
);
18250 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18253 if (attr2
&& (DW_UNSND (attr2
) != 0))
18254 list_to_add
= &global_symbols
;
18256 list_to_add
= cu
->list_in_scope
;
18260 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18263 var_decode_location (attr
, sym
, cu
);
18264 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18266 /* Fortran explicitly imports any global symbols to the local
18267 scope by DW_TAG_common_block. */
18268 if (cu
->language
== language_fortran
&& die
->parent
18269 && die
->parent
->tag
== DW_TAG_common_block
)
18272 if (SYMBOL_CLASS (sym
) == LOC_STATIC
18273 && SYMBOL_VALUE_ADDRESS (sym
) == 0
18274 && !dwarf2_per_objfile
->has_section_at_zero
)
18276 /* When a static variable is eliminated by the linker,
18277 the corresponding debug information is not stripped
18278 out, but the variable address is set to null;
18279 do not add such variables into symbol table. */
18281 else if (attr2
&& (DW_UNSND (attr2
) != 0))
18283 /* Workaround gfortran PR debug/40040 - it uses
18284 DW_AT_location for variables in -fPIC libraries which may
18285 get overriden by other libraries/executable and get
18286 a different address. Resolve it by the minimal symbol
18287 which may come from inferior's executable using copy
18288 relocation. Make this workaround only for gfortran as for
18289 other compilers GDB cannot guess the minimal symbol
18290 Fortran mangling kind. */
18291 if (cu
->language
== language_fortran
&& die
->parent
18292 && die
->parent
->tag
== DW_TAG_module
18294 && startswith (cu
->producer
, "GNU Fortran "))
18295 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18297 /* A variable with DW_AT_external is never static,
18298 but it may be block-scoped. */
18299 list_to_add
= (cu
->list_in_scope
== &file_symbols
18300 ? &global_symbols
: cu
->list_in_scope
);
18303 list_to_add
= cu
->list_in_scope
;
18307 /* We do not know the address of this symbol.
18308 If it is an external symbol and we have type information
18309 for it, enter the symbol as a LOC_UNRESOLVED symbol.
18310 The address of the variable will then be determined from
18311 the minimal symbol table whenever the variable is
18313 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18315 /* Fortran explicitly imports any global symbols to the local
18316 scope by DW_TAG_common_block. */
18317 if (cu
->language
== language_fortran
&& die
->parent
18318 && die
->parent
->tag
== DW_TAG_common_block
)
18320 /* SYMBOL_CLASS doesn't matter here because
18321 read_common_block is going to reset it. */
18323 list_to_add
= cu
->list_in_scope
;
18325 else if (attr2
&& (DW_UNSND (attr2
) != 0)
18326 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
18328 /* A variable with DW_AT_external is never static, but it
18329 may be block-scoped. */
18330 list_to_add
= (cu
->list_in_scope
== &file_symbols
18331 ? &global_symbols
: cu
->list_in_scope
);
18333 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18335 else if (!die_is_declaration (die
, cu
))
18337 /* Use the default LOC_OPTIMIZED_OUT class. */
18338 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
18340 list_to_add
= cu
->list_in_scope
;
18344 case DW_TAG_formal_parameter
:
18345 /* If we are inside a function, mark this as an argument. If
18346 not, we might be looking at an argument to an inlined function
18347 when we do not have enough information to show inlined frames;
18348 pretend it's a local variable in that case so that the user can
18350 if (context_stack_depth
> 0
18351 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
18352 SYMBOL_IS_ARGUMENT (sym
) = 1;
18353 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18356 var_decode_location (attr
, sym
, cu
);
18358 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18361 dwarf2_const_value (attr
, sym
, cu
);
18364 list_to_add
= cu
->list_in_scope
;
18366 case DW_TAG_unspecified_parameters
:
18367 /* From varargs functions; gdb doesn't seem to have any
18368 interest in this information, so just ignore it for now.
18371 case DW_TAG_template_type_param
:
18373 /* Fall through. */
18374 case DW_TAG_class_type
:
18375 case DW_TAG_interface_type
:
18376 case DW_TAG_structure_type
:
18377 case DW_TAG_union_type
:
18378 case DW_TAG_set_type
:
18379 case DW_TAG_enumeration_type
:
18380 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18381 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
18384 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
18385 really ever be static objects: otherwise, if you try
18386 to, say, break of a class's method and you're in a file
18387 which doesn't mention that class, it won't work unless
18388 the check for all static symbols in lookup_symbol_aux
18389 saves you. See the OtherFileClass tests in
18390 gdb.c++/namespace.exp. */
18394 list_to_add
= (cu
->list_in_scope
== &file_symbols
18395 && (cu
->language
== language_cplus
18396 || cu
->language
== language_java
)
18397 ? &global_symbols
: cu
->list_in_scope
);
18399 /* The semantics of C++ state that "struct foo {
18400 ... }" also defines a typedef for "foo". A Java
18401 class declaration also defines a typedef for the
18403 if (cu
->language
== language_cplus
18404 || cu
->language
== language_java
18405 || cu
->language
== language_ada
)
18407 /* The symbol's name is already allocated along
18408 with this objfile, so we don't need to
18409 duplicate it for the type. */
18410 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
18411 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
18416 case DW_TAG_typedef
:
18417 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18418 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18419 list_to_add
= cu
->list_in_scope
;
18421 case DW_TAG_base_type
:
18422 case DW_TAG_subrange_type
:
18423 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18424 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18425 list_to_add
= cu
->list_in_scope
;
18427 case DW_TAG_enumerator
:
18428 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18431 dwarf2_const_value (attr
, sym
, cu
);
18434 /* NOTE: carlton/2003-11-10: See comment above in the
18435 DW_TAG_class_type, etc. block. */
18437 list_to_add
= (cu
->list_in_scope
== &file_symbols
18438 && (cu
->language
== language_cplus
18439 || cu
->language
== language_java
)
18440 ? &global_symbols
: cu
->list_in_scope
);
18443 case DW_TAG_imported_declaration
:
18444 case DW_TAG_namespace
:
18445 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18446 list_to_add
= &global_symbols
;
18448 case DW_TAG_module
:
18449 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18450 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
18451 list_to_add
= &global_symbols
;
18453 case DW_TAG_common_block
:
18454 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
18455 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
18456 add_symbol_to_list (sym
, cu
->list_in_scope
);
18459 /* Not a tag we recognize. Hopefully we aren't processing
18460 trash data, but since we must specifically ignore things
18461 we don't recognize, there is nothing else we should do at
18463 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
18464 dwarf_tag_name (die
->tag
));
18470 sym
->hash_next
= objfile
->template_symbols
;
18471 objfile
->template_symbols
= sym
;
18472 list_to_add
= NULL
;
18475 if (list_to_add
!= NULL
)
18476 add_symbol_to_list (sym
, list_to_add
);
18478 /* For the benefit of old versions of GCC, check for anonymous
18479 namespaces based on the demangled name. */
18480 if (!cu
->processing_has_namespace_info
18481 && cu
->language
== language_cplus
)
18482 cp_scan_for_anonymous_namespaces (sym
, objfile
);
18487 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18489 static struct symbol
*
18490 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
18492 return new_symbol_full (die
, type
, cu
, NULL
);
18495 /* Given an attr with a DW_FORM_dataN value in host byte order,
18496 zero-extend it as appropriate for the symbol's type. The DWARF
18497 standard (v4) is not entirely clear about the meaning of using
18498 DW_FORM_dataN for a constant with a signed type, where the type is
18499 wider than the data. The conclusion of a discussion on the DWARF
18500 list was that this is unspecified. We choose to always zero-extend
18501 because that is the interpretation long in use by GCC. */
18504 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
18505 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
18507 struct objfile
*objfile
= cu
->objfile
;
18508 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
18509 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
18510 LONGEST l
= DW_UNSND (attr
);
18512 if (bits
< sizeof (*value
) * 8)
18514 l
&= ((LONGEST
) 1 << bits
) - 1;
18517 else if (bits
== sizeof (*value
) * 8)
18521 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
18522 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
18529 /* Read a constant value from an attribute. Either set *VALUE, or if
18530 the value does not fit in *VALUE, set *BYTES - either already
18531 allocated on the objfile obstack, or newly allocated on OBSTACK,
18532 or, set *BATON, if we translated the constant to a location
18536 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
18537 const char *name
, struct obstack
*obstack
,
18538 struct dwarf2_cu
*cu
,
18539 LONGEST
*value
, const gdb_byte
**bytes
,
18540 struct dwarf2_locexpr_baton
**baton
)
18542 struct objfile
*objfile
= cu
->objfile
;
18543 struct comp_unit_head
*cu_header
= &cu
->header
;
18544 struct dwarf_block
*blk
;
18545 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
18546 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
18552 switch (attr
->form
)
18555 case DW_FORM_GNU_addr_index
:
18559 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
18560 dwarf2_const_value_length_mismatch_complaint (name
,
18561 cu_header
->addr_size
,
18562 TYPE_LENGTH (type
));
18563 /* Symbols of this form are reasonably rare, so we just
18564 piggyback on the existing location code rather than writing
18565 a new implementation of symbol_computed_ops. */
18566 *baton
= obstack_alloc (obstack
, sizeof (struct dwarf2_locexpr_baton
));
18567 (*baton
)->per_cu
= cu
->per_cu
;
18568 gdb_assert ((*baton
)->per_cu
);
18570 (*baton
)->size
= 2 + cu_header
->addr_size
;
18571 data
= obstack_alloc (obstack
, (*baton
)->size
);
18572 (*baton
)->data
= data
;
18574 data
[0] = DW_OP_addr
;
18575 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
18576 byte_order
, DW_ADDR (attr
));
18577 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
18580 case DW_FORM_string
:
18582 case DW_FORM_GNU_str_index
:
18583 case DW_FORM_GNU_strp_alt
:
18584 /* DW_STRING is already allocated on the objfile obstack, point
18586 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
18588 case DW_FORM_block1
:
18589 case DW_FORM_block2
:
18590 case DW_FORM_block4
:
18591 case DW_FORM_block
:
18592 case DW_FORM_exprloc
:
18593 blk
= DW_BLOCK (attr
);
18594 if (TYPE_LENGTH (type
) != blk
->size
)
18595 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
18596 TYPE_LENGTH (type
));
18597 *bytes
= blk
->data
;
18600 /* The DW_AT_const_value attributes are supposed to carry the
18601 symbol's value "represented as it would be on the target
18602 architecture." By the time we get here, it's already been
18603 converted to host endianness, so we just need to sign- or
18604 zero-extend it as appropriate. */
18605 case DW_FORM_data1
:
18606 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
18608 case DW_FORM_data2
:
18609 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
18611 case DW_FORM_data4
:
18612 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
18614 case DW_FORM_data8
:
18615 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
18618 case DW_FORM_sdata
:
18619 *value
= DW_SND (attr
);
18622 case DW_FORM_udata
:
18623 *value
= DW_UNSND (attr
);
18627 complaint (&symfile_complaints
,
18628 _("unsupported const value attribute form: '%s'"),
18629 dwarf_form_name (attr
->form
));
18636 /* Copy constant value from an attribute to a symbol. */
18639 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
18640 struct dwarf2_cu
*cu
)
18642 struct objfile
*objfile
= cu
->objfile
;
18643 struct comp_unit_head
*cu_header
= &cu
->header
;
18645 const gdb_byte
*bytes
;
18646 struct dwarf2_locexpr_baton
*baton
;
18648 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
18649 SYMBOL_PRINT_NAME (sym
),
18650 &objfile
->objfile_obstack
, cu
,
18651 &value
, &bytes
, &baton
);
18655 SYMBOL_LOCATION_BATON (sym
) = baton
;
18656 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
18658 else if (bytes
!= NULL
)
18660 SYMBOL_VALUE_BYTES (sym
) = bytes
;
18661 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
18665 SYMBOL_VALUE (sym
) = value
;
18666 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
18670 /* Return the type of the die in question using its DW_AT_type attribute. */
18672 static struct type
*
18673 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18675 struct attribute
*type_attr
;
18677 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
18680 /* A missing DW_AT_type represents a void type. */
18681 return objfile_type (cu
->objfile
)->builtin_void
;
18684 return lookup_die_type (die
, type_attr
, cu
);
18687 /* True iff CU's producer generates GNAT Ada auxiliary information
18688 that allows to find parallel types through that information instead
18689 of having to do expensive parallel lookups by type name. */
18692 need_gnat_info (struct dwarf2_cu
*cu
)
18694 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18695 of GNAT produces this auxiliary information, without any indication
18696 that it is produced. Part of enhancing the FSF version of GNAT
18697 to produce that information will be to put in place an indicator
18698 that we can use in order to determine whether the descriptive type
18699 info is available or not. One suggestion that has been made is
18700 to use a new attribute, attached to the CU die. For now, assume
18701 that the descriptive type info is not available. */
18705 /* Return the auxiliary type of the die in question using its
18706 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18707 attribute is not present. */
18709 static struct type
*
18710 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18712 struct attribute
*type_attr
;
18714 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
18718 return lookup_die_type (die
, type_attr
, cu
);
18721 /* If DIE has a descriptive_type attribute, then set the TYPE's
18722 descriptive type accordingly. */
18725 set_descriptive_type (struct type
*type
, struct die_info
*die
,
18726 struct dwarf2_cu
*cu
)
18728 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
18730 if (descriptive_type
)
18732 ALLOCATE_GNAT_AUX_TYPE (type
);
18733 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
18737 /* Return the containing type of the die in question using its
18738 DW_AT_containing_type attribute. */
18740 static struct type
*
18741 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18743 struct attribute
*type_attr
;
18745 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
18747 error (_("Dwarf Error: Problem turning containing type into gdb type "
18748 "[in module %s]"), objfile_name (cu
->objfile
));
18750 return lookup_die_type (die
, type_attr
, cu
);
18753 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18755 static struct type
*
18756 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
18758 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18759 char *message
, *saved
;
18761 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18762 objfile_name (objfile
),
18763 cu
->header
.offset
.sect_off
,
18764 die
->offset
.sect_off
);
18765 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
18766 message
, strlen (message
));
18769 return init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
18772 /* Look up the type of DIE in CU using its type attribute ATTR.
18773 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18774 DW_AT_containing_type.
18775 If there is no type substitute an error marker. */
18777 static struct type
*
18778 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
18779 struct dwarf2_cu
*cu
)
18781 struct objfile
*objfile
= cu
->objfile
;
18782 struct type
*this_type
;
18784 gdb_assert (attr
->name
== DW_AT_type
18785 || attr
->name
== DW_AT_GNAT_descriptive_type
18786 || attr
->name
== DW_AT_containing_type
);
18788 /* First see if we have it cached. */
18790 if (attr
->form
== DW_FORM_GNU_ref_alt
)
18792 struct dwarf2_per_cu_data
*per_cu
;
18793 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18795 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
18796 this_type
= get_die_type_at_offset (offset
, per_cu
);
18798 else if (attr_form_is_ref (attr
))
18800 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18802 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
18804 else if (attr
->form
== DW_FORM_ref_sig8
)
18806 ULONGEST signature
= DW_SIGNATURE (attr
);
18808 return get_signatured_type (die
, signature
, cu
);
18812 complaint (&symfile_complaints
,
18813 _("Dwarf Error: Bad type attribute %s in DIE"
18814 " at 0x%x [in module %s]"),
18815 dwarf_attr_name (attr
->name
), die
->offset
.sect_off
,
18816 objfile_name (objfile
));
18817 return build_error_marker_type (cu
, die
);
18820 /* If not cached we need to read it in. */
18822 if (this_type
== NULL
)
18824 struct die_info
*type_die
= NULL
;
18825 struct dwarf2_cu
*type_cu
= cu
;
18827 if (attr_form_is_ref (attr
))
18828 type_die
= follow_die_ref (die
, attr
, &type_cu
);
18829 if (type_die
== NULL
)
18830 return build_error_marker_type (cu
, die
);
18831 /* If we find the type now, it's probably because the type came
18832 from an inter-CU reference and the type's CU got expanded before
18834 this_type
= read_type_die (type_die
, type_cu
);
18837 /* If we still don't have a type use an error marker. */
18839 if (this_type
== NULL
)
18840 return build_error_marker_type (cu
, die
);
18845 /* Return the type in DIE, CU.
18846 Returns NULL for invalid types.
18848 This first does a lookup in die_type_hash,
18849 and only reads the die in if necessary.
18851 NOTE: This can be called when reading in partial or full symbols. */
18853 static struct type
*
18854 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
18856 struct type
*this_type
;
18858 this_type
= get_die_type (die
, cu
);
18862 return read_type_die_1 (die
, cu
);
18865 /* Read the type in DIE, CU.
18866 Returns NULL for invalid types. */
18868 static struct type
*
18869 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
18871 struct type
*this_type
= NULL
;
18875 case DW_TAG_class_type
:
18876 case DW_TAG_interface_type
:
18877 case DW_TAG_structure_type
:
18878 case DW_TAG_union_type
:
18879 this_type
= read_structure_type (die
, cu
);
18881 case DW_TAG_enumeration_type
:
18882 this_type
= read_enumeration_type (die
, cu
);
18884 case DW_TAG_subprogram
:
18885 case DW_TAG_subroutine_type
:
18886 case DW_TAG_inlined_subroutine
:
18887 this_type
= read_subroutine_type (die
, cu
);
18889 case DW_TAG_array_type
:
18890 this_type
= read_array_type (die
, cu
);
18892 case DW_TAG_set_type
:
18893 this_type
= read_set_type (die
, cu
);
18895 case DW_TAG_pointer_type
:
18896 this_type
= read_tag_pointer_type (die
, cu
);
18898 case DW_TAG_ptr_to_member_type
:
18899 this_type
= read_tag_ptr_to_member_type (die
, cu
);
18901 case DW_TAG_reference_type
:
18902 this_type
= read_tag_reference_type (die
, cu
);
18904 case DW_TAG_const_type
:
18905 this_type
= read_tag_const_type (die
, cu
);
18907 case DW_TAG_volatile_type
:
18908 this_type
= read_tag_volatile_type (die
, cu
);
18910 case DW_TAG_restrict_type
:
18911 this_type
= read_tag_restrict_type (die
, cu
);
18913 case DW_TAG_string_type
:
18914 this_type
= read_tag_string_type (die
, cu
);
18916 case DW_TAG_typedef
:
18917 this_type
= read_typedef (die
, cu
);
18919 case DW_TAG_subrange_type
:
18920 this_type
= read_subrange_type (die
, cu
);
18922 case DW_TAG_base_type
:
18923 this_type
= read_base_type (die
, cu
);
18925 case DW_TAG_unspecified_type
:
18926 this_type
= read_unspecified_type (die
, cu
);
18928 case DW_TAG_namespace
:
18929 this_type
= read_namespace_type (die
, cu
);
18931 case DW_TAG_module
:
18932 this_type
= read_module_type (die
, cu
);
18934 case DW_TAG_atomic_type
:
18935 this_type
= read_tag_atomic_type (die
, cu
);
18938 complaint (&symfile_complaints
,
18939 _("unexpected tag in read_type_die: '%s'"),
18940 dwarf_tag_name (die
->tag
));
18947 /* See if we can figure out if the class lives in a namespace. We do
18948 this by looking for a member function; its demangled name will
18949 contain namespace info, if there is any.
18950 Return the computed name or NULL.
18951 Space for the result is allocated on the objfile's obstack.
18952 This is the full-die version of guess_partial_die_structure_name.
18953 In this case we know DIE has no useful parent. */
18956 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
18958 struct die_info
*spec_die
;
18959 struct dwarf2_cu
*spec_cu
;
18960 struct die_info
*child
;
18963 spec_die
= die_specification (die
, &spec_cu
);
18964 if (spec_die
!= NULL
)
18970 for (child
= die
->child
;
18972 child
= child
->sibling
)
18974 if (child
->tag
== DW_TAG_subprogram
)
18976 struct attribute
*attr
;
18978 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
18980 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
18984 = language_class_name_from_physname (cu
->language_defn
,
18988 if (actual_name
!= NULL
)
18990 const char *die_name
= dwarf2_name (die
, cu
);
18992 if (die_name
!= NULL
18993 && strcmp (die_name
, actual_name
) != 0)
18995 /* Strip off the class name from the full name.
18996 We want the prefix. */
18997 int die_name_len
= strlen (die_name
);
18998 int actual_name_len
= strlen (actual_name
);
19000 /* Test for '::' as a sanity check. */
19001 if (actual_name_len
> die_name_len
+ 2
19002 && actual_name
[actual_name_len
19003 - die_name_len
- 1] == ':')
19005 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19007 actual_name_len
- die_name_len
- 2);
19010 xfree (actual_name
);
19019 /* GCC might emit a nameless typedef that has a linkage name. Determine the
19020 prefix part in such case. See
19021 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19024 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19026 struct attribute
*attr
;
19029 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
19030 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
19033 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19034 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19037 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19039 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19040 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19043 /* dwarf2_name had to be already called. */
19044 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
19046 /* Strip the base name, keep any leading namespaces/classes. */
19047 base
= strrchr (DW_STRING (attr
), ':');
19048 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
19051 return obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19052 DW_STRING (attr
), &base
[-1] - DW_STRING (attr
));
19055 /* Return the name of the namespace/class that DIE is defined within,
19056 or "" if we can't tell. The caller should not xfree the result.
19058 For example, if we're within the method foo() in the following
19068 then determine_prefix on foo's die will return "N::C". */
19070 static const char *
19071 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19073 struct die_info
*parent
, *spec_die
;
19074 struct dwarf2_cu
*spec_cu
;
19075 struct type
*parent_type
;
19078 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
19079 && cu
->language
!= language_fortran
)
19082 retval
= anonymous_struct_prefix (die
, cu
);
19086 /* We have to be careful in the presence of DW_AT_specification.
19087 For example, with GCC 3.4, given the code
19091 // Definition of N::foo.
19095 then we'll have a tree of DIEs like this:
19097 1: DW_TAG_compile_unit
19098 2: DW_TAG_namespace // N
19099 3: DW_TAG_subprogram // declaration of N::foo
19100 4: DW_TAG_subprogram // definition of N::foo
19101 DW_AT_specification // refers to die #3
19103 Thus, when processing die #4, we have to pretend that we're in
19104 the context of its DW_AT_specification, namely the contex of die
19107 spec_die
= die_specification (die
, &spec_cu
);
19108 if (spec_die
== NULL
)
19109 parent
= die
->parent
;
19112 parent
= spec_die
->parent
;
19116 if (parent
== NULL
)
19118 else if (parent
->building_fullname
)
19121 const char *parent_name
;
19123 /* It has been seen on RealView 2.2 built binaries,
19124 DW_TAG_template_type_param types actually _defined_ as
19125 children of the parent class:
19128 template class <class Enum> Class{};
19129 Class<enum E> class_e;
19131 1: DW_TAG_class_type (Class)
19132 2: DW_TAG_enumeration_type (E)
19133 3: DW_TAG_enumerator (enum1:0)
19134 3: DW_TAG_enumerator (enum2:1)
19136 2: DW_TAG_template_type_param
19137 DW_AT_type DW_FORM_ref_udata (E)
19139 Besides being broken debug info, it can put GDB into an
19140 infinite loop. Consider:
19142 When we're building the full name for Class<E>, we'll start
19143 at Class, and go look over its template type parameters,
19144 finding E. We'll then try to build the full name of E, and
19145 reach here. We're now trying to build the full name of E,
19146 and look over the parent DIE for containing scope. In the
19147 broken case, if we followed the parent DIE of E, we'd again
19148 find Class, and once again go look at its template type
19149 arguments, etc., etc. Simply don't consider such parent die
19150 as source-level parent of this die (it can't be, the language
19151 doesn't allow it), and break the loop here. */
19152 name
= dwarf2_name (die
, cu
);
19153 parent_name
= dwarf2_name (parent
, cu
);
19154 complaint (&symfile_complaints
,
19155 _("template param type '%s' defined within parent '%s'"),
19156 name
? name
: "<unknown>",
19157 parent_name
? parent_name
: "<unknown>");
19161 switch (parent
->tag
)
19163 case DW_TAG_namespace
:
19164 parent_type
= read_type_die (parent
, cu
);
19165 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
19166 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
19167 Work around this problem here. */
19168 if (cu
->language
== language_cplus
19169 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
19171 /* We give a name to even anonymous namespaces. */
19172 return TYPE_TAG_NAME (parent_type
);
19173 case DW_TAG_class_type
:
19174 case DW_TAG_interface_type
:
19175 case DW_TAG_structure_type
:
19176 case DW_TAG_union_type
:
19177 case DW_TAG_module
:
19178 parent_type
= read_type_die (parent
, cu
);
19179 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19180 return TYPE_TAG_NAME (parent_type
);
19182 /* An anonymous structure is only allowed non-static data
19183 members; no typedefs, no member functions, et cetera.
19184 So it does not need a prefix. */
19186 case DW_TAG_compile_unit
:
19187 case DW_TAG_partial_unit
:
19188 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
19189 if (cu
->language
== language_cplus
19190 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
19191 && die
->child
!= NULL
19192 && (die
->tag
== DW_TAG_class_type
19193 || die
->tag
== DW_TAG_structure_type
19194 || die
->tag
== DW_TAG_union_type
))
19196 char *name
= guess_full_die_structure_name (die
, cu
);
19201 case DW_TAG_enumeration_type
:
19202 parent_type
= read_type_die (parent
, cu
);
19203 if (TYPE_DECLARED_CLASS (parent_type
))
19205 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19206 return TYPE_TAG_NAME (parent_type
);
19209 /* Fall through. */
19211 return determine_prefix (parent
, cu
);
19215 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
19216 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
19217 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
19218 an obconcat, otherwise allocate storage for the result. The CU argument is
19219 used to determine the language and hence, the appropriate separator. */
19221 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
19224 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
19225 int physname
, struct dwarf2_cu
*cu
)
19227 const char *lead
= "";
19230 if (suffix
== NULL
|| suffix
[0] == '\0'
19231 || prefix
== NULL
|| prefix
[0] == '\0')
19233 else if (cu
->language
== language_java
)
19235 else if (cu
->language
== language_fortran
&& physname
)
19237 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
19238 DW_AT_MIPS_linkage_name is preferred and used instead. */
19246 if (prefix
== NULL
)
19248 if (suffix
== NULL
)
19254 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
19256 strcpy (retval
, lead
);
19257 strcat (retval
, prefix
);
19258 strcat (retval
, sep
);
19259 strcat (retval
, suffix
);
19264 /* We have an obstack. */
19265 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
19269 /* Return sibling of die, NULL if no sibling. */
19271 static struct die_info
*
19272 sibling_die (struct die_info
*die
)
19274 return die
->sibling
;
19277 /* Get name of a die, return NULL if not found. */
19279 static const char *
19280 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
19281 struct obstack
*obstack
)
19283 if (name
&& cu
->language
== language_cplus
)
19285 char *canon_name
= cp_canonicalize_string (name
);
19287 if (canon_name
!= NULL
)
19289 if (strcmp (canon_name
, name
) != 0)
19290 name
= obstack_copy0 (obstack
, canon_name
, strlen (canon_name
));
19291 xfree (canon_name
);
19298 /* Get name of a die, return NULL if not found.
19299 Anonymous namespaces are converted to their magic string. */
19301 static const char *
19302 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19304 struct attribute
*attr
;
19306 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19307 if ((!attr
|| !DW_STRING (attr
))
19308 && die
->tag
!= DW_TAG_namespace
19309 && die
->tag
!= DW_TAG_class_type
19310 && die
->tag
!= DW_TAG_interface_type
19311 && die
->tag
!= DW_TAG_structure_type
19312 && die
->tag
!= DW_TAG_union_type
)
19317 case DW_TAG_compile_unit
:
19318 case DW_TAG_partial_unit
:
19319 /* Compilation units have a DW_AT_name that is a filename, not
19320 a source language identifier. */
19321 case DW_TAG_enumeration_type
:
19322 case DW_TAG_enumerator
:
19323 /* These tags always have simple identifiers already; no need
19324 to canonicalize them. */
19325 return DW_STRING (attr
);
19327 case DW_TAG_namespace
:
19328 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19329 return DW_STRING (attr
);
19330 return CP_ANONYMOUS_NAMESPACE_STR
;
19332 case DW_TAG_subprogram
:
19333 /* Java constructors will all be named "<init>", so return
19334 the class name when we see this special case. */
19335 if (cu
->language
== language_java
19336 && DW_STRING (attr
) != NULL
19337 && strcmp (DW_STRING (attr
), "<init>") == 0)
19339 struct dwarf2_cu
*spec_cu
= cu
;
19340 struct die_info
*spec_die
;
19342 /* GCJ will output '<init>' for Java constructor names.
19343 For this special case, return the name of the parent class. */
19345 /* GCJ may output subprogram DIEs with AT_specification set.
19346 If so, use the name of the specified DIE. */
19347 spec_die
= die_specification (die
, &spec_cu
);
19348 if (spec_die
!= NULL
)
19349 return dwarf2_name (spec_die
, spec_cu
);
19354 if (die
->tag
== DW_TAG_class_type
)
19355 return dwarf2_name (die
, cu
);
19357 while (die
->tag
!= DW_TAG_compile_unit
19358 && die
->tag
!= DW_TAG_partial_unit
);
19362 case DW_TAG_class_type
:
19363 case DW_TAG_interface_type
:
19364 case DW_TAG_structure_type
:
19365 case DW_TAG_union_type
:
19366 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19367 structures or unions. These were of the form "._%d" in GCC 4.1,
19368 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19369 and GCC 4.4. We work around this problem by ignoring these. */
19370 if (attr
&& DW_STRING (attr
)
19371 && (startswith (DW_STRING (attr
), "._")
19372 || startswith (DW_STRING (attr
), "<anonymous")))
19375 /* GCC might emit a nameless typedef that has a linkage name. See
19376 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19377 if (!attr
|| DW_STRING (attr
) == NULL
)
19379 char *demangled
= NULL
;
19381 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19383 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19385 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19388 /* Avoid demangling DW_STRING (attr) the second time on a second
19389 call for the same DIE. */
19390 if (!DW_STRING_IS_CANONICAL (attr
))
19391 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
19397 /* FIXME: we already did this for the partial symbol... */
19399 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19400 demangled
, strlen (demangled
));
19401 DW_STRING_IS_CANONICAL (attr
) = 1;
19404 /* Strip any leading namespaces/classes, keep only the base name.
19405 DW_AT_name for named DIEs does not contain the prefixes. */
19406 base
= strrchr (DW_STRING (attr
), ':');
19407 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
19410 return DW_STRING (attr
);
19419 if (!DW_STRING_IS_CANONICAL (attr
))
19422 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
19423 &cu
->objfile
->per_bfd
->storage_obstack
);
19424 DW_STRING_IS_CANONICAL (attr
) = 1;
19426 return DW_STRING (attr
);
19429 /* Return the die that this die in an extension of, or NULL if there
19430 is none. *EXT_CU is the CU containing DIE on input, and the CU
19431 containing the return value on output. */
19433 static struct die_info
*
19434 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
19436 struct attribute
*attr
;
19438 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
19442 return follow_die_ref (die
, attr
, ext_cu
);
19445 /* Convert a DIE tag into its string name. */
19447 static const char *
19448 dwarf_tag_name (unsigned tag
)
19450 const char *name
= get_DW_TAG_name (tag
);
19453 return "DW_TAG_<unknown>";
19458 /* Convert a DWARF attribute code into its string name. */
19460 static const char *
19461 dwarf_attr_name (unsigned attr
)
19465 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19466 if (attr
== DW_AT_MIPS_fde
)
19467 return "DW_AT_MIPS_fde";
19469 if (attr
== DW_AT_HP_block_index
)
19470 return "DW_AT_HP_block_index";
19473 name
= get_DW_AT_name (attr
);
19476 return "DW_AT_<unknown>";
19481 /* Convert a DWARF value form code into its string name. */
19483 static const char *
19484 dwarf_form_name (unsigned form
)
19486 const char *name
= get_DW_FORM_name (form
);
19489 return "DW_FORM_<unknown>";
19495 dwarf_bool_name (unsigned mybool
)
19503 /* Convert a DWARF type code into its string name. */
19505 static const char *
19506 dwarf_type_encoding_name (unsigned enc
)
19508 const char *name
= get_DW_ATE_name (enc
);
19511 return "DW_ATE_<unknown>";
19517 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
19521 print_spaces (indent
, f
);
19522 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
19523 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
19525 if (die
->parent
!= NULL
)
19527 print_spaces (indent
, f
);
19528 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
19529 die
->parent
->offset
.sect_off
);
19532 print_spaces (indent
, f
);
19533 fprintf_unfiltered (f
, " has children: %s\n",
19534 dwarf_bool_name (die
->child
!= NULL
));
19536 print_spaces (indent
, f
);
19537 fprintf_unfiltered (f
, " attributes:\n");
19539 for (i
= 0; i
< die
->num_attrs
; ++i
)
19541 print_spaces (indent
, f
);
19542 fprintf_unfiltered (f
, " %s (%s) ",
19543 dwarf_attr_name (die
->attrs
[i
].name
),
19544 dwarf_form_name (die
->attrs
[i
].form
));
19546 switch (die
->attrs
[i
].form
)
19549 case DW_FORM_GNU_addr_index
:
19550 fprintf_unfiltered (f
, "address: ");
19551 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
19553 case DW_FORM_block2
:
19554 case DW_FORM_block4
:
19555 case DW_FORM_block
:
19556 case DW_FORM_block1
:
19557 fprintf_unfiltered (f
, "block: size %s",
19558 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19560 case DW_FORM_exprloc
:
19561 fprintf_unfiltered (f
, "expression: size %s",
19562 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19564 case DW_FORM_ref_addr
:
19565 fprintf_unfiltered (f
, "ref address: ");
19566 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19568 case DW_FORM_GNU_ref_alt
:
19569 fprintf_unfiltered (f
, "alt ref address: ");
19570 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19576 case DW_FORM_ref_udata
:
19577 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
19578 (long) (DW_UNSND (&die
->attrs
[i
])));
19580 case DW_FORM_data1
:
19581 case DW_FORM_data2
:
19582 case DW_FORM_data4
:
19583 case DW_FORM_data8
:
19584 case DW_FORM_udata
:
19585 case DW_FORM_sdata
:
19586 fprintf_unfiltered (f
, "constant: %s",
19587 pulongest (DW_UNSND (&die
->attrs
[i
])));
19589 case DW_FORM_sec_offset
:
19590 fprintf_unfiltered (f
, "section offset: %s",
19591 pulongest (DW_UNSND (&die
->attrs
[i
])));
19593 case DW_FORM_ref_sig8
:
19594 fprintf_unfiltered (f
, "signature: %s",
19595 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
19597 case DW_FORM_string
:
19599 case DW_FORM_GNU_str_index
:
19600 case DW_FORM_GNU_strp_alt
:
19601 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
19602 DW_STRING (&die
->attrs
[i
])
19603 ? DW_STRING (&die
->attrs
[i
]) : "",
19604 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
19607 if (DW_UNSND (&die
->attrs
[i
]))
19608 fprintf_unfiltered (f
, "flag: TRUE");
19610 fprintf_unfiltered (f
, "flag: FALSE");
19612 case DW_FORM_flag_present
:
19613 fprintf_unfiltered (f
, "flag: TRUE");
19615 case DW_FORM_indirect
:
19616 /* The reader will have reduced the indirect form to
19617 the "base form" so this form should not occur. */
19618 fprintf_unfiltered (f
,
19619 "unexpected attribute form: DW_FORM_indirect");
19622 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
19623 die
->attrs
[i
].form
);
19626 fprintf_unfiltered (f
, "\n");
19631 dump_die_for_error (struct die_info
*die
)
19633 dump_die_shallow (gdb_stderr
, 0, die
);
19637 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
19639 int indent
= level
* 4;
19641 gdb_assert (die
!= NULL
);
19643 if (level
>= max_level
)
19646 dump_die_shallow (f
, indent
, die
);
19648 if (die
->child
!= NULL
)
19650 print_spaces (indent
, f
);
19651 fprintf_unfiltered (f
, " Children:");
19652 if (level
+ 1 < max_level
)
19654 fprintf_unfiltered (f
, "\n");
19655 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
19659 fprintf_unfiltered (f
,
19660 " [not printed, max nesting level reached]\n");
19664 if (die
->sibling
!= NULL
&& level
> 0)
19666 dump_die_1 (f
, level
, max_level
, die
->sibling
);
19670 /* This is called from the pdie macro in gdbinit.in.
19671 It's not static so gcc will keep a copy callable from gdb. */
19674 dump_die (struct die_info
*die
, int max_level
)
19676 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
19680 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
19684 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
19690 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19694 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
19696 sect_offset retval
= { DW_UNSND (attr
) };
19698 if (attr_form_is_ref (attr
))
19701 retval
.sect_off
= 0;
19702 complaint (&symfile_complaints
,
19703 _("unsupported die ref attribute form: '%s'"),
19704 dwarf_form_name (attr
->form
));
19708 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19709 * the value held by the attribute is not constant. */
19712 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
19714 if (attr
->form
== DW_FORM_sdata
)
19715 return DW_SND (attr
);
19716 else if (attr
->form
== DW_FORM_udata
19717 || attr
->form
== DW_FORM_data1
19718 || attr
->form
== DW_FORM_data2
19719 || attr
->form
== DW_FORM_data4
19720 || attr
->form
== DW_FORM_data8
)
19721 return DW_UNSND (attr
);
19724 complaint (&symfile_complaints
,
19725 _("Attribute value is not a constant (%s)"),
19726 dwarf_form_name (attr
->form
));
19727 return default_value
;
19731 /* Follow reference or signature attribute ATTR of SRC_DIE.
19732 On entry *REF_CU is the CU of SRC_DIE.
19733 On exit *REF_CU is the CU of the result. */
19735 static struct die_info
*
19736 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
19737 struct dwarf2_cu
**ref_cu
)
19739 struct die_info
*die
;
19741 if (attr_form_is_ref (attr
))
19742 die
= follow_die_ref (src_die
, attr
, ref_cu
);
19743 else if (attr
->form
== DW_FORM_ref_sig8
)
19744 die
= follow_die_sig (src_die
, attr
, ref_cu
);
19747 dump_die_for_error (src_die
);
19748 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19749 objfile_name ((*ref_cu
)->objfile
));
19755 /* Follow reference OFFSET.
19756 On entry *REF_CU is the CU of the source die referencing OFFSET.
19757 On exit *REF_CU is the CU of the result.
19758 Returns NULL if OFFSET is invalid. */
19760 static struct die_info
*
19761 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
19762 struct dwarf2_cu
**ref_cu
)
19764 struct die_info temp_die
;
19765 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
19767 gdb_assert (cu
->per_cu
!= NULL
);
19771 if (cu
->per_cu
->is_debug_types
)
19773 /* .debug_types CUs cannot reference anything outside their CU.
19774 If they need to, they have to reference a signatured type via
19775 DW_FORM_ref_sig8. */
19776 if (! offset_in_cu_p (&cu
->header
, offset
))
19779 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
19780 || ! offset_in_cu_p (&cu
->header
, offset
))
19782 struct dwarf2_per_cu_data
*per_cu
;
19784 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
19787 /* If necessary, add it to the queue and load its DIEs. */
19788 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
19789 load_full_comp_unit (per_cu
, cu
->language
);
19791 target_cu
= per_cu
->cu
;
19793 else if (cu
->dies
== NULL
)
19795 /* We're loading full DIEs during partial symbol reading. */
19796 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
19797 load_full_comp_unit (cu
->per_cu
, language_minimal
);
19800 *ref_cu
= target_cu
;
19801 temp_die
.offset
= offset
;
19802 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
19805 /* Follow reference attribute ATTR of SRC_DIE.
19806 On entry *REF_CU is the CU of SRC_DIE.
19807 On exit *REF_CU is the CU of the result. */
19809 static struct die_info
*
19810 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
19811 struct dwarf2_cu
**ref_cu
)
19813 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
19814 struct dwarf2_cu
*cu
= *ref_cu
;
19815 struct die_info
*die
;
19817 die
= follow_die_offset (offset
,
19818 (attr
->form
== DW_FORM_GNU_ref_alt
19819 || cu
->per_cu
->is_dwz
),
19822 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19823 "at 0x%x [in module %s]"),
19824 offset
.sect_off
, src_die
->offset
.sect_off
,
19825 objfile_name (cu
->objfile
));
19830 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19831 Returned value is intended for DW_OP_call*. Returned
19832 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19834 struct dwarf2_locexpr_baton
19835 dwarf2_fetch_die_loc_sect_off (sect_offset offset
,
19836 struct dwarf2_per_cu_data
*per_cu
,
19837 CORE_ADDR (*get_frame_pc
) (void *baton
),
19840 struct dwarf2_cu
*cu
;
19841 struct die_info
*die
;
19842 struct attribute
*attr
;
19843 struct dwarf2_locexpr_baton retval
;
19845 dw2_setup (per_cu
->objfile
);
19847 if (per_cu
->cu
== NULL
)
19851 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
19853 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19854 offset
.sect_off
, objfile_name (per_cu
->objfile
));
19856 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
19859 /* DWARF: "If there is no such attribute, then there is no effect.".
19860 DATA is ignored if SIZE is 0. */
19862 retval
.data
= NULL
;
19865 else if (attr_form_is_section_offset (attr
))
19867 struct dwarf2_loclist_baton loclist_baton
;
19868 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
19871 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
19873 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
19875 retval
.size
= size
;
19879 if (!attr_form_is_block (attr
))
19880 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
19881 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
19882 offset
.sect_off
, objfile_name (per_cu
->objfile
));
19884 retval
.data
= DW_BLOCK (attr
)->data
;
19885 retval
.size
= DW_BLOCK (attr
)->size
;
19887 retval
.per_cu
= cu
->per_cu
;
19889 age_cached_comp_units ();
19894 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
19897 struct dwarf2_locexpr_baton
19898 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
19899 struct dwarf2_per_cu_data
*per_cu
,
19900 CORE_ADDR (*get_frame_pc
) (void *baton
),
19903 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
19905 return dwarf2_fetch_die_loc_sect_off (offset
, per_cu
, get_frame_pc
, baton
);
19908 /* Write a constant of a given type as target-ordered bytes into
19911 static const gdb_byte
*
19912 write_constant_as_bytes (struct obstack
*obstack
,
19913 enum bfd_endian byte_order
,
19920 *len
= TYPE_LENGTH (type
);
19921 result
= obstack_alloc (obstack
, *len
);
19922 store_unsigned_integer (result
, *len
, byte_order
, value
);
19927 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
19928 pointer to the constant bytes and set LEN to the length of the
19929 data. If memory is needed, allocate it on OBSTACK. If the DIE
19930 does not have a DW_AT_const_value, return NULL. */
19933 dwarf2_fetch_constant_bytes (sect_offset offset
,
19934 struct dwarf2_per_cu_data
*per_cu
,
19935 struct obstack
*obstack
,
19938 struct dwarf2_cu
*cu
;
19939 struct die_info
*die
;
19940 struct attribute
*attr
;
19941 const gdb_byte
*result
= NULL
;
19944 enum bfd_endian byte_order
;
19946 dw2_setup (per_cu
->objfile
);
19948 if (per_cu
->cu
== NULL
)
19952 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
19954 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19955 offset
.sect_off
, objfile_name (per_cu
->objfile
));
19958 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
19962 byte_order
= (bfd_big_endian (per_cu
->objfile
->obfd
)
19963 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
19965 switch (attr
->form
)
19968 case DW_FORM_GNU_addr_index
:
19972 *len
= cu
->header
.addr_size
;
19973 tem
= obstack_alloc (obstack
, *len
);
19974 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
19978 case DW_FORM_string
:
19980 case DW_FORM_GNU_str_index
:
19981 case DW_FORM_GNU_strp_alt
:
19982 /* DW_STRING is already allocated on the objfile obstack, point
19984 result
= (const gdb_byte
*) DW_STRING (attr
);
19985 *len
= strlen (DW_STRING (attr
));
19987 case DW_FORM_block1
:
19988 case DW_FORM_block2
:
19989 case DW_FORM_block4
:
19990 case DW_FORM_block
:
19991 case DW_FORM_exprloc
:
19992 result
= DW_BLOCK (attr
)->data
;
19993 *len
= DW_BLOCK (attr
)->size
;
19996 /* The DW_AT_const_value attributes are supposed to carry the
19997 symbol's value "represented as it would be on the target
19998 architecture." By the time we get here, it's already been
19999 converted to host endianness, so we just need to sign- or
20000 zero-extend it as appropriate. */
20001 case DW_FORM_data1
:
20002 type
= die_type (die
, cu
);
20003 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
20004 if (result
== NULL
)
20005 result
= write_constant_as_bytes (obstack
, byte_order
,
20008 case DW_FORM_data2
:
20009 type
= die_type (die
, cu
);
20010 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
20011 if (result
== NULL
)
20012 result
= write_constant_as_bytes (obstack
, byte_order
,
20015 case DW_FORM_data4
:
20016 type
= die_type (die
, cu
);
20017 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
20018 if (result
== NULL
)
20019 result
= write_constant_as_bytes (obstack
, byte_order
,
20022 case DW_FORM_data8
:
20023 type
= die_type (die
, cu
);
20024 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
20025 if (result
== NULL
)
20026 result
= write_constant_as_bytes (obstack
, byte_order
,
20030 case DW_FORM_sdata
:
20031 type
= die_type (die
, cu
);
20032 result
= write_constant_as_bytes (obstack
, byte_order
,
20033 type
, DW_SND (attr
), len
);
20036 case DW_FORM_udata
:
20037 type
= die_type (die
, cu
);
20038 result
= write_constant_as_bytes (obstack
, byte_order
,
20039 type
, DW_UNSND (attr
), len
);
20043 complaint (&symfile_complaints
,
20044 _("unsupported const value attribute form: '%s'"),
20045 dwarf_form_name (attr
->form
));
20052 /* Return the type of the DIE at DIE_OFFSET in the CU named by
20056 dwarf2_get_die_type (cu_offset die_offset
,
20057 struct dwarf2_per_cu_data
*per_cu
)
20059 sect_offset die_offset_sect
;
20061 dw2_setup (per_cu
->objfile
);
20063 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
20064 return get_die_type_at_offset (die_offset_sect
, per_cu
);
20067 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
20068 On entry *REF_CU is the CU of SRC_DIE.
20069 On exit *REF_CU is the CU of the result.
20070 Returns NULL if the referenced DIE isn't found. */
20072 static struct die_info
*
20073 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
20074 struct dwarf2_cu
**ref_cu
)
20076 struct objfile
*objfile
= (*ref_cu
)->objfile
;
20077 struct die_info temp_die
;
20078 struct dwarf2_cu
*sig_cu
;
20079 struct die_info
*die
;
20081 /* While it might be nice to assert sig_type->type == NULL here,
20082 we can get here for DW_AT_imported_declaration where we need
20083 the DIE not the type. */
20085 /* If necessary, add it to the queue and load its DIEs. */
20087 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
20088 read_signatured_type (sig_type
);
20090 sig_cu
= sig_type
->per_cu
.cu
;
20091 gdb_assert (sig_cu
!= NULL
);
20092 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
20093 temp_die
.offset
= sig_type
->type_offset_in_section
;
20094 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
20095 temp_die
.offset
.sect_off
);
20098 /* For .gdb_index version 7 keep track of included TUs.
20099 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
20100 if (dwarf2_per_objfile
->index_table
!= NULL
20101 && dwarf2_per_objfile
->index_table
->version
<= 7)
20103 VEC_safe_push (dwarf2_per_cu_ptr
,
20104 (*ref_cu
)->per_cu
->imported_symtabs
,
20115 /* Follow signatured type referenced by ATTR in SRC_DIE.
20116 On entry *REF_CU is the CU of SRC_DIE.
20117 On exit *REF_CU is the CU of the result.
20118 The result is the DIE of the type.
20119 If the referenced type cannot be found an error is thrown. */
20121 static struct die_info
*
20122 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
20123 struct dwarf2_cu
**ref_cu
)
20125 ULONGEST signature
= DW_SIGNATURE (attr
);
20126 struct signatured_type
*sig_type
;
20127 struct die_info
*die
;
20129 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
20131 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
20132 /* sig_type will be NULL if the signatured type is missing from
20134 if (sig_type
== NULL
)
20136 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
20137 " from DIE at 0x%x [in module %s]"),
20138 hex_string (signature
), src_die
->offset
.sect_off
,
20139 objfile_name ((*ref_cu
)->objfile
));
20142 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
20145 dump_die_for_error (src_die
);
20146 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
20147 " from DIE at 0x%x [in module %s]"),
20148 hex_string (signature
), src_die
->offset
.sect_off
,
20149 objfile_name ((*ref_cu
)->objfile
));
20155 /* Get the type specified by SIGNATURE referenced in DIE/CU,
20156 reading in and processing the type unit if necessary. */
20158 static struct type
*
20159 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
20160 struct dwarf2_cu
*cu
)
20162 struct signatured_type
*sig_type
;
20163 struct dwarf2_cu
*type_cu
;
20164 struct die_info
*type_die
;
20167 sig_type
= lookup_signatured_type (cu
, signature
);
20168 /* sig_type will be NULL if the signatured type is missing from
20170 if (sig_type
== NULL
)
20172 complaint (&symfile_complaints
,
20173 _("Dwarf Error: Cannot find signatured DIE %s referenced"
20174 " from DIE at 0x%x [in module %s]"),
20175 hex_string (signature
), die
->offset
.sect_off
,
20176 objfile_name (dwarf2_per_objfile
->objfile
));
20177 return build_error_marker_type (cu
, die
);
20180 /* If we already know the type we're done. */
20181 if (sig_type
->type
!= NULL
)
20182 return sig_type
->type
;
20185 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
20186 if (type_die
!= NULL
)
20188 /* N.B. We need to call get_die_type to ensure only one type for this DIE
20189 is created. This is important, for example, because for c++ classes
20190 we need TYPE_NAME set which is only done by new_symbol. Blech. */
20191 type
= read_type_die (type_die
, type_cu
);
20194 complaint (&symfile_complaints
,
20195 _("Dwarf Error: Cannot build signatured type %s"
20196 " referenced from DIE at 0x%x [in module %s]"),
20197 hex_string (signature
), die
->offset
.sect_off
,
20198 objfile_name (dwarf2_per_objfile
->objfile
));
20199 type
= build_error_marker_type (cu
, die
);
20204 complaint (&symfile_complaints
,
20205 _("Dwarf Error: Problem reading signatured DIE %s referenced"
20206 " from DIE at 0x%x [in module %s]"),
20207 hex_string (signature
), die
->offset
.sect_off
,
20208 objfile_name (dwarf2_per_objfile
->objfile
));
20209 type
= build_error_marker_type (cu
, die
);
20211 sig_type
->type
= type
;
20216 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
20217 reading in and processing the type unit if necessary. */
20219 static struct type
*
20220 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
20221 struct dwarf2_cu
*cu
) /* ARI: editCase function */
20223 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
20224 if (attr_form_is_ref (attr
))
20226 struct dwarf2_cu
*type_cu
= cu
;
20227 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
20229 return read_type_die (type_die
, type_cu
);
20231 else if (attr
->form
== DW_FORM_ref_sig8
)
20233 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
20237 complaint (&symfile_complaints
,
20238 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
20239 " at 0x%x [in module %s]"),
20240 dwarf_form_name (attr
->form
), die
->offset
.sect_off
,
20241 objfile_name (dwarf2_per_objfile
->objfile
));
20242 return build_error_marker_type (cu
, die
);
20246 /* Load the DIEs associated with type unit PER_CU into memory. */
20249 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
20251 struct signatured_type
*sig_type
;
20253 /* Caller is responsible for ensuring type_unit_groups don't get here. */
20254 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
20256 /* We have the per_cu, but we need the signatured_type.
20257 Fortunately this is an easy translation. */
20258 gdb_assert (per_cu
->is_debug_types
);
20259 sig_type
= (struct signatured_type
*) per_cu
;
20261 gdb_assert (per_cu
->cu
== NULL
);
20263 read_signatured_type (sig_type
);
20265 gdb_assert (per_cu
->cu
!= NULL
);
20268 /* die_reader_func for read_signatured_type.
20269 This is identical to load_full_comp_unit_reader,
20270 but is kept separate for now. */
20273 read_signatured_type_reader (const struct die_reader_specs
*reader
,
20274 const gdb_byte
*info_ptr
,
20275 struct die_info
*comp_unit_die
,
20279 struct dwarf2_cu
*cu
= reader
->cu
;
20281 gdb_assert (cu
->die_hash
== NULL
);
20283 htab_create_alloc_ex (cu
->header
.length
/ 12,
20287 &cu
->comp_unit_obstack
,
20288 hashtab_obstack_allocate
,
20289 dummy_obstack_deallocate
);
20292 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
20293 &info_ptr
, comp_unit_die
);
20294 cu
->dies
= comp_unit_die
;
20295 /* comp_unit_die is not stored in die_hash, no need. */
20297 /* We try not to read any attributes in this function, because not
20298 all CUs needed for references have been loaded yet, and symbol
20299 table processing isn't initialized. But we have to set the CU language,
20300 or we won't be able to build types correctly.
20301 Similarly, if we do not read the producer, we can not apply
20302 producer-specific interpretation. */
20303 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
20306 /* Read in a signatured type and build its CU and DIEs.
20307 If the type is a stub for the real type in a DWO file,
20308 read in the real type from the DWO file as well. */
20311 read_signatured_type (struct signatured_type
*sig_type
)
20313 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
20315 gdb_assert (per_cu
->is_debug_types
);
20316 gdb_assert (per_cu
->cu
== NULL
);
20318 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
20319 read_signatured_type_reader
, NULL
);
20320 sig_type
->per_cu
.tu_read
= 1;
20323 /* Decode simple location descriptions.
20324 Given a pointer to a dwarf block that defines a location, compute
20325 the location and return the value.
20327 NOTE drow/2003-11-18: This function is called in two situations
20328 now: for the address of static or global variables (partial symbols
20329 only) and for offsets into structures which are expected to be
20330 (more or less) constant. The partial symbol case should go away,
20331 and only the constant case should remain. That will let this
20332 function complain more accurately. A few special modes are allowed
20333 without complaint for global variables (for instance, global
20334 register values and thread-local values).
20336 A location description containing no operations indicates that the
20337 object is optimized out. The return value is 0 for that case.
20338 FIXME drow/2003-11-16: No callers check for this case any more; soon all
20339 callers will only want a very basic result and this can become a
20342 Note that stack[0] is unused except as a default error return. */
20345 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
20347 struct objfile
*objfile
= cu
->objfile
;
20349 size_t size
= blk
->size
;
20350 const gdb_byte
*data
= blk
->data
;
20351 CORE_ADDR stack
[64];
20353 unsigned int bytes_read
, unsnd
;
20359 stack
[++stacki
] = 0;
20398 stack
[++stacki
] = op
- DW_OP_lit0
;
20433 stack
[++stacki
] = op
- DW_OP_reg0
;
20435 dwarf2_complex_location_expr_complaint ();
20439 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
20441 stack
[++stacki
] = unsnd
;
20443 dwarf2_complex_location_expr_complaint ();
20447 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
20452 case DW_OP_const1u
:
20453 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
20457 case DW_OP_const1s
:
20458 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
20462 case DW_OP_const2u
:
20463 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
20467 case DW_OP_const2s
:
20468 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
20472 case DW_OP_const4u
:
20473 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
20477 case DW_OP_const4s
:
20478 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
20482 case DW_OP_const8u
:
20483 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
20488 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
20494 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
20499 stack
[stacki
+ 1] = stack
[stacki
];
20504 stack
[stacki
- 1] += stack
[stacki
];
20508 case DW_OP_plus_uconst
:
20509 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
20515 stack
[stacki
- 1] -= stack
[stacki
];
20520 /* If we're not the last op, then we definitely can't encode
20521 this using GDB's address_class enum. This is valid for partial
20522 global symbols, although the variable's address will be bogus
20525 dwarf2_complex_location_expr_complaint ();
20528 case DW_OP_GNU_push_tls_address
:
20529 /* The top of the stack has the offset from the beginning
20530 of the thread control block at which the variable is located. */
20531 /* Nothing should follow this operator, so the top of stack would
20533 /* This is valid for partial global symbols, but the variable's
20534 address will be bogus in the psymtab. Make it always at least
20535 non-zero to not look as a variable garbage collected by linker
20536 which have DW_OP_addr 0. */
20538 dwarf2_complex_location_expr_complaint ();
20542 case DW_OP_GNU_uninit
:
20545 case DW_OP_GNU_addr_index
:
20546 case DW_OP_GNU_const_index
:
20547 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
20554 const char *name
= get_DW_OP_name (op
);
20557 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
20560 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
20564 return (stack
[stacki
]);
20567 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20568 outside of the allocated space. Also enforce minimum>0. */
20569 if (stacki
>= ARRAY_SIZE (stack
) - 1)
20571 complaint (&symfile_complaints
,
20572 _("location description stack overflow"));
20578 complaint (&symfile_complaints
,
20579 _("location description stack underflow"));
20583 return (stack
[stacki
]);
20586 /* memory allocation interface */
20588 static struct dwarf_block
*
20589 dwarf_alloc_block (struct dwarf2_cu
*cu
)
20591 struct dwarf_block
*blk
;
20593 blk
= (struct dwarf_block
*)
20594 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
20598 static struct die_info
*
20599 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
20601 struct die_info
*die
;
20602 size_t size
= sizeof (struct die_info
);
20605 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
20607 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
20608 memset (die
, 0, sizeof (struct die_info
));
20613 /* Macro support. */
20615 /* Return file name relative to the compilation directory of file number I in
20616 *LH's file name table. The result is allocated using xmalloc; the caller is
20617 responsible for freeing it. */
20620 file_file_name (int file
, struct line_header
*lh
)
20622 /* Is the file number a valid index into the line header's file name
20623 table? Remember that file numbers start with one, not zero. */
20624 if (1 <= file
&& file
<= lh
->num_file_names
)
20626 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
20628 if (IS_ABSOLUTE_PATH (fe
->name
) || fe
->dir_index
== 0)
20629 return xstrdup (fe
->name
);
20630 return concat (lh
->include_dirs
[fe
->dir_index
- 1], SLASH_STRING
,
20635 /* The compiler produced a bogus file number. We can at least
20636 record the macro definitions made in the file, even if we
20637 won't be able to find the file by name. */
20638 char fake_name
[80];
20640 xsnprintf (fake_name
, sizeof (fake_name
),
20641 "<bad macro file number %d>", file
);
20643 complaint (&symfile_complaints
,
20644 _("bad file number in macro information (%d)"),
20647 return xstrdup (fake_name
);
20651 /* Return the full name of file number I in *LH's file name table.
20652 Use COMP_DIR as the name of the current directory of the
20653 compilation. The result is allocated using xmalloc; the caller is
20654 responsible for freeing it. */
20656 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
20658 /* Is the file number a valid index into the line header's file name
20659 table? Remember that file numbers start with one, not zero. */
20660 if (1 <= file
&& file
<= lh
->num_file_names
)
20662 char *relative
= file_file_name (file
, lh
);
20664 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
20666 return reconcat (relative
, comp_dir
, SLASH_STRING
, relative
, NULL
);
20669 return file_file_name (file
, lh
);
20673 static struct macro_source_file
*
20674 macro_start_file (int file
, int line
,
20675 struct macro_source_file
*current_file
,
20676 struct line_header
*lh
)
20678 /* File name relative to the compilation directory of this source file. */
20679 char *file_name
= file_file_name (file
, lh
);
20681 if (! current_file
)
20683 /* Note: We don't create a macro table for this compilation unit
20684 at all until we actually get a filename. */
20685 struct macro_table
*macro_table
= get_macro_table ();
20687 /* If we have no current file, then this must be the start_file
20688 directive for the compilation unit's main source file. */
20689 current_file
= macro_set_main (macro_table
, file_name
);
20690 macro_define_special (macro_table
);
20693 current_file
= macro_include (current_file
, line
, file_name
);
20697 return current_file
;
20701 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20702 followed by a null byte. */
20704 copy_string (const char *buf
, int len
)
20706 char *s
= xmalloc (len
+ 1);
20708 memcpy (s
, buf
, len
);
20714 static const char *
20715 consume_improper_spaces (const char *p
, const char *body
)
20719 complaint (&symfile_complaints
,
20720 _("macro definition contains spaces "
20721 "in formal argument list:\n`%s'"),
20733 parse_macro_definition (struct macro_source_file
*file
, int line
,
20738 /* The body string takes one of two forms. For object-like macro
20739 definitions, it should be:
20741 <macro name> " " <definition>
20743 For function-like macro definitions, it should be:
20745 <macro name> "() " <definition>
20747 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20749 Spaces may appear only where explicitly indicated, and in the
20752 The Dwarf 2 spec says that an object-like macro's name is always
20753 followed by a space, but versions of GCC around March 2002 omit
20754 the space when the macro's definition is the empty string.
20756 The Dwarf 2 spec says that there should be no spaces between the
20757 formal arguments in a function-like macro's formal argument list,
20758 but versions of GCC around March 2002 include spaces after the
20762 /* Find the extent of the macro name. The macro name is terminated
20763 by either a space or null character (for an object-like macro) or
20764 an opening paren (for a function-like macro). */
20765 for (p
= body
; *p
; p
++)
20766 if (*p
== ' ' || *p
== '(')
20769 if (*p
== ' ' || *p
== '\0')
20771 /* It's an object-like macro. */
20772 int name_len
= p
- body
;
20773 char *name
= copy_string (body
, name_len
);
20774 const char *replacement
;
20777 replacement
= body
+ name_len
+ 1;
20780 dwarf2_macro_malformed_definition_complaint (body
);
20781 replacement
= body
+ name_len
;
20784 macro_define_object (file
, line
, name
, replacement
);
20788 else if (*p
== '(')
20790 /* It's a function-like macro. */
20791 char *name
= copy_string (body
, p
- body
);
20794 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
20798 p
= consume_improper_spaces (p
, body
);
20800 /* Parse the formal argument list. */
20801 while (*p
&& *p
!= ')')
20803 /* Find the extent of the current argument name. */
20804 const char *arg_start
= p
;
20806 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
20809 if (! *p
|| p
== arg_start
)
20810 dwarf2_macro_malformed_definition_complaint (body
);
20813 /* Make sure argv has room for the new argument. */
20814 if (argc
>= argv_size
)
20817 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
20820 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
20823 p
= consume_improper_spaces (p
, body
);
20825 /* Consume the comma, if present. */
20830 p
= consume_improper_spaces (p
, body
);
20839 /* Perfectly formed definition, no complaints. */
20840 macro_define_function (file
, line
, name
,
20841 argc
, (const char **) argv
,
20843 else if (*p
== '\0')
20845 /* Complain, but do define it. */
20846 dwarf2_macro_malformed_definition_complaint (body
);
20847 macro_define_function (file
, line
, name
,
20848 argc
, (const char **) argv
,
20852 /* Just complain. */
20853 dwarf2_macro_malformed_definition_complaint (body
);
20856 /* Just complain. */
20857 dwarf2_macro_malformed_definition_complaint (body
);
20863 for (i
= 0; i
< argc
; i
++)
20869 dwarf2_macro_malformed_definition_complaint (body
);
20872 /* Skip some bytes from BYTES according to the form given in FORM.
20873 Returns the new pointer. */
20875 static const gdb_byte
*
20876 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
20877 enum dwarf_form form
,
20878 unsigned int offset_size
,
20879 struct dwarf2_section_info
*section
)
20881 unsigned int bytes_read
;
20885 case DW_FORM_data1
:
20890 case DW_FORM_data2
:
20894 case DW_FORM_data4
:
20898 case DW_FORM_data8
:
20902 case DW_FORM_string
:
20903 read_direct_string (abfd
, bytes
, &bytes_read
);
20904 bytes
+= bytes_read
;
20907 case DW_FORM_sec_offset
:
20909 case DW_FORM_GNU_strp_alt
:
20910 bytes
+= offset_size
;
20913 case DW_FORM_block
:
20914 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
20915 bytes
+= bytes_read
;
20918 case DW_FORM_block1
:
20919 bytes
+= 1 + read_1_byte (abfd
, bytes
);
20921 case DW_FORM_block2
:
20922 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
20924 case DW_FORM_block4
:
20925 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
20928 case DW_FORM_sdata
:
20929 case DW_FORM_udata
:
20930 case DW_FORM_GNU_addr_index
:
20931 case DW_FORM_GNU_str_index
:
20932 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
20935 dwarf2_section_buffer_overflow_complaint (section
);
20943 complaint (&symfile_complaints
,
20944 _("invalid form 0x%x in `%s'"),
20945 form
, get_section_name (section
));
20953 /* A helper for dwarf_decode_macros that handles skipping an unknown
20954 opcode. Returns an updated pointer to the macro data buffer; or,
20955 on error, issues a complaint and returns NULL. */
20957 static const gdb_byte
*
20958 skip_unknown_opcode (unsigned int opcode
,
20959 const gdb_byte
**opcode_definitions
,
20960 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
20962 unsigned int offset_size
,
20963 struct dwarf2_section_info
*section
)
20965 unsigned int bytes_read
, i
;
20967 const gdb_byte
*defn
;
20969 if (opcode_definitions
[opcode
] == NULL
)
20971 complaint (&symfile_complaints
,
20972 _("unrecognized DW_MACFINO opcode 0x%x"),
20977 defn
= opcode_definitions
[opcode
];
20978 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
20979 defn
+= bytes_read
;
20981 for (i
= 0; i
< arg
; ++i
)
20983 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
, defn
[i
], offset_size
,
20985 if (mac_ptr
== NULL
)
20987 /* skip_form_bytes already issued the complaint. */
20995 /* A helper function which parses the header of a macro section.
20996 If the macro section is the extended (for now called "GNU") type,
20997 then this updates *OFFSET_SIZE. Returns a pointer to just after
20998 the header, or issues a complaint and returns NULL on error. */
21000 static const gdb_byte
*
21001 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
21003 const gdb_byte
*mac_ptr
,
21004 unsigned int *offset_size
,
21005 int section_is_gnu
)
21007 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
21009 if (section_is_gnu
)
21011 unsigned int version
, flags
;
21013 version
= read_2_bytes (abfd
, mac_ptr
);
21016 complaint (&symfile_complaints
,
21017 _("unrecognized version `%d' in .debug_macro section"),
21023 flags
= read_1_byte (abfd
, mac_ptr
);
21025 *offset_size
= (flags
& 1) ? 8 : 4;
21027 if ((flags
& 2) != 0)
21028 /* We don't need the line table offset. */
21029 mac_ptr
+= *offset_size
;
21031 /* Vendor opcode descriptions. */
21032 if ((flags
& 4) != 0)
21034 unsigned int i
, count
;
21036 count
= read_1_byte (abfd
, mac_ptr
);
21038 for (i
= 0; i
< count
; ++i
)
21040 unsigned int opcode
, bytes_read
;
21043 opcode
= read_1_byte (abfd
, mac_ptr
);
21045 opcode_definitions
[opcode
] = mac_ptr
;
21046 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21047 mac_ptr
+= bytes_read
;
21056 /* A helper for dwarf_decode_macros that handles the GNU extensions,
21057 including DW_MACRO_GNU_transparent_include. */
21060 dwarf_decode_macro_bytes (bfd
*abfd
,
21061 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21062 struct macro_source_file
*current_file
,
21063 struct line_header
*lh
,
21064 struct dwarf2_section_info
*section
,
21065 int section_is_gnu
, int section_is_dwz
,
21066 unsigned int offset_size
,
21067 htab_t include_hash
)
21069 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21070 enum dwarf_macro_record_type macinfo_type
;
21071 int at_commandline
;
21072 const gdb_byte
*opcode_definitions
[256];
21074 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21075 &offset_size
, section_is_gnu
);
21076 if (mac_ptr
== NULL
)
21078 /* We already issued a complaint. */
21082 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
21083 GDB is still reading the definitions from command line. First
21084 DW_MACINFO_start_file will need to be ignored as it was already executed
21085 to create CURRENT_FILE for the main source holding also the command line
21086 definitions. On first met DW_MACINFO_start_file this flag is reset to
21087 normally execute all the remaining DW_MACINFO_start_file macinfos. */
21089 at_commandline
= 1;
21093 /* Do we at least have room for a macinfo type byte? */
21094 if (mac_ptr
>= mac_end
)
21096 dwarf2_section_buffer_overflow_complaint (section
);
21100 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
21103 /* Note that we rely on the fact that the corresponding GNU and
21104 DWARF constants are the same. */
21105 switch (macinfo_type
)
21107 /* A zero macinfo type indicates the end of the macro
21112 case DW_MACRO_GNU_define
:
21113 case DW_MACRO_GNU_undef
:
21114 case DW_MACRO_GNU_define_indirect
:
21115 case DW_MACRO_GNU_undef_indirect
:
21116 case DW_MACRO_GNU_define_indirect_alt
:
21117 case DW_MACRO_GNU_undef_indirect_alt
:
21119 unsigned int bytes_read
;
21124 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21125 mac_ptr
+= bytes_read
;
21127 if (macinfo_type
== DW_MACRO_GNU_define
21128 || macinfo_type
== DW_MACRO_GNU_undef
)
21130 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21131 mac_ptr
+= bytes_read
;
21135 LONGEST str_offset
;
21137 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21138 mac_ptr
+= offset_size
;
21140 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
21141 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
21144 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21146 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
21149 body
= read_indirect_string_at_offset (abfd
, str_offset
);
21152 is_define
= (macinfo_type
== DW_MACRO_GNU_define
21153 || macinfo_type
== DW_MACRO_GNU_define_indirect
21154 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
21155 if (! current_file
)
21157 /* DWARF violation as no main source is present. */
21158 complaint (&symfile_complaints
,
21159 _("debug info with no main source gives macro %s "
21161 is_define
? _("definition") : _("undefinition"),
21165 if ((line
== 0 && !at_commandline
)
21166 || (line
!= 0 && at_commandline
))
21167 complaint (&symfile_complaints
,
21168 _("debug info gives %s macro %s with %s line %d: %s"),
21169 at_commandline
? _("command-line") : _("in-file"),
21170 is_define
? _("definition") : _("undefinition"),
21171 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
21174 parse_macro_definition (current_file
, line
, body
);
21177 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
21178 || macinfo_type
== DW_MACRO_GNU_undef_indirect
21179 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
21180 macro_undef (current_file
, line
, body
);
21185 case DW_MACRO_GNU_start_file
:
21187 unsigned int bytes_read
;
21190 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21191 mac_ptr
+= bytes_read
;
21192 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21193 mac_ptr
+= bytes_read
;
21195 if ((line
== 0 && !at_commandline
)
21196 || (line
!= 0 && at_commandline
))
21197 complaint (&symfile_complaints
,
21198 _("debug info gives source %d included "
21199 "from %s at %s line %d"),
21200 file
, at_commandline
? _("command-line") : _("file"),
21201 line
== 0 ? _("zero") : _("non-zero"), line
);
21203 if (at_commandline
)
21205 /* This DW_MACRO_GNU_start_file was executed in the
21207 at_commandline
= 0;
21210 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21214 case DW_MACRO_GNU_end_file
:
21215 if (! current_file
)
21216 complaint (&symfile_complaints
,
21217 _("macro debug info has an unmatched "
21218 "`close_file' directive"));
21221 current_file
= current_file
->included_by
;
21222 if (! current_file
)
21224 enum dwarf_macro_record_type next_type
;
21226 /* GCC circa March 2002 doesn't produce the zero
21227 type byte marking the end of the compilation
21228 unit. Complain if it's not there, but exit no
21231 /* Do we at least have room for a macinfo type byte? */
21232 if (mac_ptr
>= mac_end
)
21234 dwarf2_section_buffer_overflow_complaint (section
);
21238 /* We don't increment mac_ptr here, so this is just
21240 next_type
= read_1_byte (abfd
, mac_ptr
);
21241 if (next_type
!= 0)
21242 complaint (&symfile_complaints
,
21243 _("no terminating 0-type entry for "
21244 "macros in `.debug_macinfo' section"));
21251 case DW_MACRO_GNU_transparent_include
:
21252 case DW_MACRO_GNU_transparent_include_alt
:
21256 bfd
*include_bfd
= abfd
;
21257 struct dwarf2_section_info
*include_section
= section
;
21258 struct dwarf2_section_info alt_section
;
21259 const gdb_byte
*include_mac_end
= mac_end
;
21260 int is_dwz
= section_is_dwz
;
21261 const gdb_byte
*new_mac_ptr
;
21263 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21264 mac_ptr
+= offset_size
;
21266 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
21268 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21270 dwarf2_read_section (objfile
, &dwz
->macro
);
21272 include_section
= &dwz
->macro
;
21273 include_bfd
= get_section_bfd_owner (include_section
);
21274 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
21278 new_mac_ptr
= include_section
->buffer
+ offset
;
21279 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
21283 /* This has actually happened; see
21284 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
21285 complaint (&symfile_complaints
,
21286 _("recursive DW_MACRO_GNU_transparent_include in "
21287 ".debug_macro section"));
21291 *slot
= (void *) new_mac_ptr
;
21293 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
21294 include_mac_end
, current_file
, lh
,
21295 section
, section_is_gnu
, is_dwz
,
21296 offset_size
, include_hash
);
21298 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
21303 case DW_MACINFO_vendor_ext
:
21304 if (!section_is_gnu
)
21306 unsigned int bytes_read
;
21309 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21310 mac_ptr
+= bytes_read
;
21311 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21312 mac_ptr
+= bytes_read
;
21314 /* We don't recognize any vendor extensions. */
21320 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21321 mac_ptr
, mac_end
, abfd
, offset_size
,
21323 if (mac_ptr
== NULL
)
21327 } while (macinfo_type
!= 0);
21331 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
21332 int section_is_gnu
)
21334 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21335 struct line_header
*lh
= cu
->line_header
;
21337 const gdb_byte
*mac_ptr
, *mac_end
;
21338 struct macro_source_file
*current_file
= 0;
21339 enum dwarf_macro_record_type macinfo_type
;
21340 unsigned int offset_size
= cu
->header
.offset_size
;
21341 const gdb_byte
*opcode_definitions
[256];
21342 struct cleanup
*cleanup
;
21343 htab_t include_hash
;
21345 struct dwarf2_section_info
*section
;
21346 const char *section_name
;
21348 if (cu
->dwo_unit
!= NULL
)
21350 if (section_is_gnu
)
21352 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
21353 section_name
= ".debug_macro.dwo";
21357 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
21358 section_name
= ".debug_macinfo.dwo";
21363 if (section_is_gnu
)
21365 section
= &dwarf2_per_objfile
->macro
;
21366 section_name
= ".debug_macro";
21370 section
= &dwarf2_per_objfile
->macinfo
;
21371 section_name
= ".debug_macinfo";
21375 dwarf2_read_section (objfile
, section
);
21376 if (section
->buffer
== NULL
)
21378 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
21381 abfd
= get_section_bfd_owner (section
);
21383 /* First pass: Find the name of the base filename.
21384 This filename is needed in order to process all macros whose definition
21385 (or undefinition) comes from the command line. These macros are defined
21386 before the first DW_MACINFO_start_file entry, and yet still need to be
21387 associated to the base file.
21389 To determine the base file name, we scan the macro definitions until we
21390 reach the first DW_MACINFO_start_file entry. We then initialize
21391 CURRENT_FILE accordingly so that any macro definition found before the
21392 first DW_MACINFO_start_file can still be associated to the base file. */
21394 mac_ptr
= section
->buffer
+ offset
;
21395 mac_end
= section
->buffer
+ section
->size
;
21397 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21398 &offset_size
, section_is_gnu
);
21399 if (mac_ptr
== NULL
)
21401 /* We already issued a complaint. */
21407 /* Do we at least have room for a macinfo type byte? */
21408 if (mac_ptr
>= mac_end
)
21410 /* Complaint is printed during the second pass as GDB will probably
21411 stop the first pass earlier upon finding
21412 DW_MACINFO_start_file. */
21416 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
21419 /* Note that we rely on the fact that the corresponding GNU and
21420 DWARF constants are the same. */
21421 switch (macinfo_type
)
21423 /* A zero macinfo type indicates the end of the macro
21428 case DW_MACRO_GNU_define
:
21429 case DW_MACRO_GNU_undef
:
21430 /* Only skip the data by MAC_PTR. */
21432 unsigned int bytes_read
;
21434 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21435 mac_ptr
+= bytes_read
;
21436 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21437 mac_ptr
+= bytes_read
;
21441 case DW_MACRO_GNU_start_file
:
21443 unsigned int bytes_read
;
21446 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21447 mac_ptr
+= bytes_read
;
21448 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21449 mac_ptr
+= bytes_read
;
21451 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21455 case DW_MACRO_GNU_end_file
:
21456 /* No data to skip by MAC_PTR. */
21459 case DW_MACRO_GNU_define_indirect
:
21460 case DW_MACRO_GNU_undef_indirect
:
21461 case DW_MACRO_GNU_define_indirect_alt
:
21462 case DW_MACRO_GNU_undef_indirect_alt
:
21464 unsigned int bytes_read
;
21466 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21467 mac_ptr
+= bytes_read
;
21468 mac_ptr
+= offset_size
;
21472 case DW_MACRO_GNU_transparent_include
:
21473 case DW_MACRO_GNU_transparent_include_alt
:
21474 /* Note that, according to the spec, a transparent include
21475 chain cannot call DW_MACRO_GNU_start_file. So, we can just
21476 skip this opcode. */
21477 mac_ptr
+= offset_size
;
21480 case DW_MACINFO_vendor_ext
:
21481 /* Only skip the data by MAC_PTR. */
21482 if (!section_is_gnu
)
21484 unsigned int bytes_read
;
21486 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21487 mac_ptr
+= bytes_read
;
21488 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21489 mac_ptr
+= bytes_read
;
21494 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21495 mac_ptr
, mac_end
, abfd
, offset_size
,
21497 if (mac_ptr
== NULL
)
21501 } while (macinfo_type
!= 0 && current_file
== NULL
);
21503 /* Second pass: Process all entries.
21505 Use the AT_COMMAND_LINE flag to determine whether we are still processing
21506 command-line macro definitions/undefinitions. This flag is unset when we
21507 reach the first DW_MACINFO_start_file entry. */
21509 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
21510 NULL
, xcalloc
, xfree
);
21511 cleanup
= make_cleanup_htab_delete (include_hash
);
21512 mac_ptr
= section
->buffer
+ offset
;
21513 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
21514 *slot
= (void *) mac_ptr
;
21515 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
21516 current_file
, lh
, section
,
21517 section_is_gnu
, 0, offset_size
, include_hash
);
21518 do_cleanups (cleanup
);
21521 /* Check if the attribute's form is a DW_FORM_block*
21522 if so return true else false. */
21525 attr_form_is_block (const struct attribute
*attr
)
21527 return (attr
== NULL
? 0 :
21528 attr
->form
== DW_FORM_block1
21529 || attr
->form
== DW_FORM_block2
21530 || attr
->form
== DW_FORM_block4
21531 || attr
->form
== DW_FORM_block
21532 || attr
->form
== DW_FORM_exprloc
);
21535 /* Return non-zero if ATTR's value is a section offset --- classes
21536 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21537 You may use DW_UNSND (attr) to retrieve such offsets.
21539 Section 7.5.4, "Attribute Encodings", explains that no attribute
21540 may have a value that belongs to more than one of these classes; it
21541 would be ambiguous if we did, because we use the same forms for all
21545 attr_form_is_section_offset (const struct attribute
*attr
)
21547 return (attr
->form
== DW_FORM_data4
21548 || attr
->form
== DW_FORM_data8
21549 || attr
->form
== DW_FORM_sec_offset
);
21552 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21553 zero otherwise. When this function returns true, you can apply
21554 dwarf2_get_attr_constant_value to it.
21556 However, note that for some attributes you must check
21557 attr_form_is_section_offset before using this test. DW_FORM_data4
21558 and DW_FORM_data8 are members of both the constant class, and of
21559 the classes that contain offsets into other debug sections
21560 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21561 that, if an attribute's can be either a constant or one of the
21562 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21563 taken as section offsets, not constants. */
21566 attr_form_is_constant (const struct attribute
*attr
)
21568 switch (attr
->form
)
21570 case DW_FORM_sdata
:
21571 case DW_FORM_udata
:
21572 case DW_FORM_data1
:
21573 case DW_FORM_data2
:
21574 case DW_FORM_data4
:
21575 case DW_FORM_data8
:
21583 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21584 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21587 attr_form_is_ref (const struct attribute
*attr
)
21589 switch (attr
->form
)
21591 case DW_FORM_ref_addr
:
21596 case DW_FORM_ref_udata
:
21597 case DW_FORM_GNU_ref_alt
:
21604 /* Return the .debug_loc section to use for CU.
21605 For DWO files use .debug_loc.dwo. */
21607 static struct dwarf2_section_info
*
21608 cu_debug_loc_section (struct dwarf2_cu
*cu
)
21611 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
21612 return &dwarf2_per_objfile
->loc
;
21615 /* A helper function that fills in a dwarf2_loclist_baton. */
21618 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
21619 struct dwarf2_loclist_baton
*baton
,
21620 const struct attribute
*attr
)
21622 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21624 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
21626 baton
->per_cu
= cu
->per_cu
;
21627 gdb_assert (baton
->per_cu
);
21628 /* We don't know how long the location list is, but make sure we
21629 don't run off the edge of the section. */
21630 baton
->size
= section
->size
- DW_UNSND (attr
);
21631 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
21632 baton
->base_address
= cu
->base_address
;
21633 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
21637 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
21638 struct dwarf2_cu
*cu
, int is_block
)
21640 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21641 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21643 if (attr_form_is_section_offset (attr
)
21644 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21645 the section. If so, fall through to the complaint in the
21647 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
21649 struct dwarf2_loclist_baton
*baton
;
21651 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21652 sizeof (struct dwarf2_loclist_baton
));
21654 fill_in_loclist_baton (cu
, baton
, attr
);
21656 if (cu
->base_known
== 0)
21657 complaint (&symfile_complaints
,
21658 _("Location list used without "
21659 "specifying the CU base address."));
21661 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21662 ? dwarf2_loclist_block_index
21663 : dwarf2_loclist_index
);
21664 SYMBOL_LOCATION_BATON (sym
) = baton
;
21668 struct dwarf2_locexpr_baton
*baton
;
21670 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21671 sizeof (struct dwarf2_locexpr_baton
));
21672 baton
->per_cu
= cu
->per_cu
;
21673 gdb_assert (baton
->per_cu
);
21675 if (attr_form_is_block (attr
))
21677 /* Note that we're just copying the block's data pointer
21678 here, not the actual data. We're still pointing into the
21679 info_buffer for SYM's objfile; right now we never release
21680 that buffer, but when we do clean up properly this may
21682 baton
->size
= DW_BLOCK (attr
)->size
;
21683 baton
->data
= DW_BLOCK (attr
)->data
;
21687 dwarf2_invalid_attrib_class_complaint ("location description",
21688 SYMBOL_NATURAL_NAME (sym
));
21692 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21693 ? dwarf2_locexpr_block_index
21694 : dwarf2_locexpr_index
);
21695 SYMBOL_LOCATION_BATON (sym
) = baton
;
21699 /* Return the OBJFILE associated with the compilation unit CU. If CU
21700 came from a separate debuginfo file, then the master objfile is
21704 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
21706 struct objfile
*objfile
= per_cu
->objfile
;
21708 /* Return the master objfile, so that we can report and look up the
21709 correct file containing this variable. */
21710 if (objfile
->separate_debug_objfile_backlink
)
21711 objfile
= objfile
->separate_debug_objfile_backlink
;
21716 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21717 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21718 CU_HEADERP first. */
21720 static const struct comp_unit_head
*
21721 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
21722 struct dwarf2_per_cu_data
*per_cu
)
21724 const gdb_byte
*info_ptr
;
21727 return &per_cu
->cu
->header
;
21729 info_ptr
= per_cu
->section
->buffer
+ per_cu
->offset
.sect_off
;
21731 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
21732 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
21737 /* Return the address size given in the compilation unit header for CU. */
21740 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21742 struct comp_unit_head cu_header_local
;
21743 const struct comp_unit_head
*cu_headerp
;
21745 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21747 return cu_headerp
->addr_size
;
21750 /* Return the offset size given in the compilation unit header for CU. */
21753 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
21755 struct comp_unit_head cu_header_local
;
21756 const struct comp_unit_head
*cu_headerp
;
21758 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21760 return cu_headerp
->offset_size
;
21763 /* See its dwarf2loc.h declaration. */
21766 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21768 struct comp_unit_head cu_header_local
;
21769 const struct comp_unit_head
*cu_headerp
;
21771 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21773 if (cu_headerp
->version
== 2)
21774 return cu_headerp
->addr_size
;
21776 return cu_headerp
->offset_size
;
21779 /* Return the text offset of the CU. The returned offset comes from
21780 this CU's objfile. If this objfile came from a separate debuginfo
21781 file, then the offset may be different from the corresponding
21782 offset in the parent objfile. */
21785 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
21787 struct objfile
*objfile
= per_cu
->objfile
;
21789 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21792 /* Locate the .debug_info compilation unit from CU's objfile which contains
21793 the DIE at OFFSET. Raises an error on failure. */
21795 static struct dwarf2_per_cu_data
*
21796 dwarf2_find_containing_comp_unit (sect_offset offset
,
21797 unsigned int offset_in_dwz
,
21798 struct objfile
*objfile
)
21800 struct dwarf2_per_cu_data
*this_cu
;
21802 const sect_offset
*cu_off
;
21805 high
= dwarf2_per_objfile
->n_comp_units
- 1;
21808 struct dwarf2_per_cu_data
*mid_cu
;
21809 int mid
= low
+ (high
- low
) / 2;
21811 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
21812 cu_off
= &mid_cu
->offset
;
21813 if (mid_cu
->is_dwz
> offset_in_dwz
21814 || (mid_cu
->is_dwz
== offset_in_dwz
21815 && cu_off
->sect_off
>= offset
.sect_off
))
21820 gdb_assert (low
== high
);
21821 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
21822 cu_off
= &this_cu
->offset
;
21823 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
21825 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
21826 error (_("Dwarf Error: could not find partial DIE containing "
21827 "offset 0x%lx [in module %s]"),
21828 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
21830 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
21831 <= offset
.sect_off
);
21832 return dwarf2_per_objfile
->all_comp_units
[low
-1];
21836 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
21837 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
21838 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
21839 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
21840 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
21845 /* Initialize dwarf2_cu CU, owned by PER_CU. */
21848 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
21850 memset (cu
, 0, sizeof (*cu
));
21852 cu
->per_cu
= per_cu
;
21853 cu
->objfile
= per_cu
->objfile
;
21854 obstack_init (&cu
->comp_unit_obstack
);
21857 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
21860 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
21861 enum language pretend_language
)
21863 struct attribute
*attr
;
21865 /* Set the language we're debugging. */
21866 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
21868 set_cu_language (DW_UNSND (attr
), cu
);
21871 cu
->language
= pretend_language
;
21872 cu
->language_defn
= language_def (cu
->language
);
21875 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
21877 cu
->producer
= DW_STRING (attr
);
21880 /* Release one cached compilation unit, CU. We unlink it from the tree
21881 of compilation units, but we don't remove it from the read_in_chain;
21882 the caller is responsible for that.
21883 NOTE: DATA is a void * because this function is also used as a
21884 cleanup routine. */
21887 free_heap_comp_unit (void *data
)
21889 struct dwarf2_cu
*cu
= data
;
21891 gdb_assert (cu
->per_cu
!= NULL
);
21892 cu
->per_cu
->cu
= NULL
;
21895 obstack_free (&cu
->comp_unit_obstack
, NULL
);
21900 /* This cleanup function is passed the address of a dwarf2_cu on the stack
21901 when we're finished with it. We can't free the pointer itself, but be
21902 sure to unlink it from the cache. Also release any associated storage. */
21905 free_stack_comp_unit (void *data
)
21907 struct dwarf2_cu
*cu
= data
;
21909 gdb_assert (cu
->per_cu
!= NULL
);
21910 cu
->per_cu
->cu
= NULL
;
21913 obstack_free (&cu
->comp_unit_obstack
, NULL
);
21914 cu
->partial_dies
= NULL
;
21917 /* Free all cached compilation units. */
21920 free_cached_comp_units (void *data
)
21922 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
21924 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21925 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
21926 while (per_cu
!= NULL
)
21928 struct dwarf2_per_cu_data
*next_cu
;
21930 next_cu
= per_cu
->cu
->read_in_chain
;
21932 free_heap_comp_unit (per_cu
->cu
);
21933 *last_chain
= next_cu
;
21939 /* Increase the age counter on each cached compilation unit, and free
21940 any that are too old. */
21943 age_cached_comp_units (void)
21945 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
21947 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
21948 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21949 while (per_cu
!= NULL
)
21951 per_cu
->cu
->last_used
++;
21952 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
21953 dwarf2_mark (per_cu
->cu
);
21954 per_cu
= per_cu
->cu
->read_in_chain
;
21957 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21958 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
21959 while (per_cu
!= NULL
)
21961 struct dwarf2_per_cu_data
*next_cu
;
21963 next_cu
= per_cu
->cu
->read_in_chain
;
21965 if (!per_cu
->cu
->mark
)
21967 free_heap_comp_unit (per_cu
->cu
);
21968 *last_chain
= next_cu
;
21971 last_chain
= &per_cu
->cu
->read_in_chain
;
21977 /* Remove a single compilation unit from the cache. */
21980 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
21982 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
21984 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21985 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
21986 while (per_cu
!= NULL
)
21988 struct dwarf2_per_cu_data
*next_cu
;
21990 next_cu
= per_cu
->cu
->read_in_chain
;
21992 if (per_cu
== target_per_cu
)
21994 free_heap_comp_unit (per_cu
->cu
);
21996 *last_chain
= next_cu
;
22000 last_chain
= &per_cu
->cu
->read_in_chain
;
22006 /* Release all extra memory associated with OBJFILE. */
22009 dwarf2_free_objfile (struct objfile
*objfile
)
22011 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
22013 if (dwarf2_per_objfile
== NULL
)
22016 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
22017 free_cached_comp_units (NULL
);
22019 if (dwarf2_per_objfile
->quick_file_names_table
)
22020 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
22022 if (dwarf2_per_objfile
->line_header_hash
)
22023 htab_delete (dwarf2_per_objfile
->line_header_hash
);
22025 /* Everything else should be on the objfile obstack. */
22028 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
22029 We store these in a hash table separate from the DIEs, and preserve them
22030 when the DIEs are flushed out of cache.
22032 The CU "per_cu" pointer is needed because offset alone is not enough to
22033 uniquely identify the type. A file may have multiple .debug_types sections,
22034 or the type may come from a DWO file. Furthermore, while it's more logical
22035 to use per_cu->section+offset, with Fission the section with the data is in
22036 the DWO file but we don't know that section at the point we need it.
22037 We have to use something in dwarf2_per_cu_data (or the pointer to it)
22038 because we can enter the lookup routine, get_die_type_at_offset, from
22039 outside this file, and thus won't necessarily have PER_CU->cu.
22040 Fortunately, PER_CU is stable for the life of the objfile. */
22042 struct dwarf2_per_cu_offset_and_type
22044 const struct dwarf2_per_cu_data
*per_cu
;
22045 sect_offset offset
;
22049 /* Hash function for a dwarf2_per_cu_offset_and_type. */
22052 per_cu_offset_and_type_hash (const void *item
)
22054 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
22056 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
22059 /* Equality function for a dwarf2_per_cu_offset_and_type. */
22062 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
22064 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
22065 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
22067 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
22068 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
22071 /* Set the type associated with DIE to TYPE. Save it in CU's hash
22072 table if necessary. For convenience, return TYPE.
22074 The DIEs reading must have careful ordering to:
22075 * Not cause infite loops trying to read in DIEs as a prerequisite for
22076 reading current DIE.
22077 * Not trying to dereference contents of still incompletely read in types
22078 while reading in other DIEs.
22079 * Enable referencing still incompletely read in types just by a pointer to
22080 the type without accessing its fields.
22082 Therefore caller should follow these rules:
22083 * Try to fetch any prerequisite types we may need to build this DIE type
22084 before building the type and calling set_die_type.
22085 * After building type call set_die_type for current DIE as soon as
22086 possible before fetching more types to complete the current type.
22087 * Make the type as complete as possible before fetching more types. */
22089 static struct type
*
22090 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
22092 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
22093 struct objfile
*objfile
= cu
->objfile
;
22094 struct attribute
*attr
;
22095 struct dynamic_prop prop
;
22097 /* For Ada types, make sure that the gnat-specific data is always
22098 initialized (if not already set). There are a few types where
22099 we should not be doing so, because the type-specific area is
22100 already used to hold some other piece of info (eg: TYPE_CODE_FLT
22101 where the type-specific area is used to store the floatformat).
22102 But this is not a problem, because the gnat-specific information
22103 is actually not needed for these types. */
22104 if (need_gnat_info (cu
)
22105 && TYPE_CODE (type
) != TYPE_CODE_FUNC
22106 && TYPE_CODE (type
) != TYPE_CODE_FLT
22107 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
22108 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
22109 && TYPE_CODE (type
) != TYPE_CODE_METHOD
22110 && !HAVE_GNAT_AUX_INFO (type
))
22111 INIT_GNAT_SPECIFIC (type
);
22113 /* Read DW_AT_data_location and set in type. */
22114 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
22115 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
22116 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
, objfile
);
22118 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22120 dwarf2_per_objfile
->die_type_hash
=
22121 htab_create_alloc_ex (127,
22122 per_cu_offset_and_type_hash
,
22123 per_cu_offset_and_type_eq
,
22125 &objfile
->objfile_obstack
,
22126 hashtab_obstack_allocate
,
22127 dummy_obstack_deallocate
);
22130 ofs
.per_cu
= cu
->per_cu
;
22131 ofs
.offset
= die
->offset
;
22133 slot
= (struct dwarf2_per_cu_offset_and_type
**)
22134 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
22136 complaint (&symfile_complaints
,
22137 _("A problem internal to GDB: DIE 0x%x has type already set"),
22138 die
->offset
.sect_off
);
22139 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
22144 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
22145 or return NULL if the die does not have a saved type. */
22147 static struct type
*
22148 get_die_type_at_offset (sect_offset offset
,
22149 struct dwarf2_per_cu_data
*per_cu
)
22151 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
22153 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22156 ofs
.per_cu
= per_cu
;
22157 ofs
.offset
= offset
;
22158 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
22165 /* Look up the type for DIE in CU in die_type_hash,
22166 or return NULL if DIE does not have a saved type. */
22168 static struct type
*
22169 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22171 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
22174 /* Add a dependence relationship from CU to REF_PER_CU. */
22177 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
22178 struct dwarf2_per_cu_data
*ref_per_cu
)
22182 if (cu
->dependencies
== NULL
)
22184 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
22185 NULL
, &cu
->comp_unit_obstack
,
22186 hashtab_obstack_allocate
,
22187 dummy_obstack_deallocate
);
22189 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
22191 *slot
= ref_per_cu
;
22194 /* Subroutine of dwarf2_mark to pass to htab_traverse.
22195 Set the mark field in every compilation unit in the
22196 cache that we must keep because we are keeping CU. */
22199 dwarf2_mark_helper (void **slot
, void *data
)
22201 struct dwarf2_per_cu_data
*per_cu
;
22203 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
22205 /* cu->dependencies references may not yet have been ever read if QUIT aborts
22206 reading of the chain. As such dependencies remain valid it is not much
22207 useful to track and undo them during QUIT cleanups. */
22208 if (per_cu
->cu
== NULL
)
22211 if (per_cu
->cu
->mark
)
22213 per_cu
->cu
->mark
= 1;
22215 if (per_cu
->cu
->dependencies
!= NULL
)
22216 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22221 /* Set the mark field in CU and in every other compilation unit in the
22222 cache that we must keep because we are keeping CU. */
22225 dwarf2_mark (struct dwarf2_cu
*cu
)
22230 if (cu
->dependencies
!= NULL
)
22231 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22235 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
22239 per_cu
->cu
->mark
= 0;
22240 per_cu
= per_cu
->cu
->read_in_chain
;
22244 /* Trivial hash function for partial_die_info: the hash value of a DIE
22245 is its offset in .debug_info for this objfile. */
22248 partial_die_hash (const void *item
)
22250 const struct partial_die_info
*part_die
= item
;
22252 return part_die
->offset
.sect_off
;
22255 /* Trivial comparison function for partial_die_info structures: two DIEs
22256 are equal if they have the same offset. */
22259 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
22261 const struct partial_die_info
*part_die_lhs
= item_lhs
;
22262 const struct partial_die_info
*part_die_rhs
= item_rhs
;
22264 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
22267 static struct cmd_list_element
*set_dwarf2_cmdlist
;
22268 static struct cmd_list_element
*show_dwarf2_cmdlist
;
22271 set_dwarf2_cmd (char *args
, int from_tty
)
22273 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", all_commands
,
22278 show_dwarf2_cmd (char *args
, int from_tty
)
22280 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
22283 /* Free data associated with OBJFILE, if necessary. */
22286 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
22288 struct dwarf2_per_objfile
*data
= d
;
22291 /* Make sure we don't accidentally use dwarf2_per_objfile while
22293 dwarf2_per_objfile
= NULL
;
22295 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
22296 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
22298 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
22299 VEC_free (dwarf2_per_cu_ptr
,
22300 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
22301 xfree (data
->all_type_units
);
22303 VEC_free (dwarf2_section_info_def
, data
->types
);
22305 if (data
->dwo_files
)
22306 free_dwo_files (data
->dwo_files
, objfile
);
22307 if (data
->dwp_file
)
22308 gdb_bfd_unref (data
->dwp_file
->dbfd
);
22310 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
22311 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
22315 /* The "save gdb-index" command. */
22317 /* The contents of the hash table we create when building the string
22319 struct strtab_entry
22321 offset_type offset
;
22325 /* Hash function for a strtab_entry.
22327 Function is used only during write_hash_table so no index format backward
22328 compatibility is needed. */
22331 hash_strtab_entry (const void *e
)
22333 const struct strtab_entry
*entry
= e
;
22334 return mapped_index_string_hash (INT_MAX
, entry
->str
);
22337 /* Equality function for a strtab_entry. */
22340 eq_strtab_entry (const void *a
, const void *b
)
22342 const struct strtab_entry
*ea
= a
;
22343 const struct strtab_entry
*eb
= b
;
22344 return !strcmp (ea
->str
, eb
->str
);
22347 /* Create a strtab_entry hash table. */
22350 create_strtab (void)
22352 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
22353 xfree
, xcalloc
, xfree
);
22356 /* Add a string to the constant pool. Return the string's offset in
22360 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
22363 struct strtab_entry entry
;
22364 struct strtab_entry
*result
;
22367 slot
= htab_find_slot (table
, &entry
, INSERT
);
22372 result
= XNEW (struct strtab_entry
);
22373 result
->offset
= obstack_object_size (cpool
);
22375 obstack_grow_str0 (cpool
, str
);
22378 return result
->offset
;
22381 /* An entry in the symbol table. */
22382 struct symtab_index_entry
22384 /* The name of the symbol. */
22386 /* The offset of the name in the constant pool. */
22387 offset_type index_offset
;
22388 /* A sorted vector of the indices of all the CUs that hold an object
22390 VEC (offset_type
) *cu_indices
;
22393 /* The symbol table. This is a power-of-2-sized hash table. */
22394 struct mapped_symtab
22396 offset_type n_elements
;
22398 struct symtab_index_entry
**data
;
22401 /* Hash function for a symtab_index_entry. */
22404 hash_symtab_entry (const void *e
)
22406 const struct symtab_index_entry
*entry
= e
;
22407 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
22408 sizeof (offset_type
) * VEC_length (offset_type
,
22409 entry
->cu_indices
),
22413 /* Equality function for a symtab_index_entry. */
22416 eq_symtab_entry (const void *a
, const void *b
)
22418 const struct symtab_index_entry
*ea
= a
;
22419 const struct symtab_index_entry
*eb
= b
;
22420 int len
= VEC_length (offset_type
, ea
->cu_indices
);
22421 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
22423 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
22424 VEC_address (offset_type
, eb
->cu_indices
),
22425 sizeof (offset_type
) * len
);
22428 /* Destroy a symtab_index_entry. */
22431 delete_symtab_entry (void *p
)
22433 struct symtab_index_entry
*entry
= p
;
22434 VEC_free (offset_type
, entry
->cu_indices
);
22438 /* Create a hash table holding symtab_index_entry objects. */
22441 create_symbol_hash_table (void)
22443 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
22444 delete_symtab_entry
, xcalloc
, xfree
);
22447 /* Create a new mapped symtab object. */
22449 static struct mapped_symtab
*
22450 create_mapped_symtab (void)
22452 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
22453 symtab
->n_elements
= 0;
22454 symtab
->size
= 1024;
22455 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22459 /* Destroy a mapped_symtab. */
22462 cleanup_mapped_symtab (void *p
)
22464 struct mapped_symtab
*symtab
= p
;
22465 /* The contents of the array are freed when the other hash table is
22467 xfree (symtab
->data
);
22471 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22474 Function is used only during write_hash_table so no index format backward
22475 compatibility is needed. */
22477 static struct symtab_index_entry
**
22478 find_slot (struct mapped_symtab
*symtab
, const char *name
)
22480 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
22482 index
= hash
& (symtab
->size
- 1);
22483 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
22487 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
22488 return &symtab
->data
[index
];
22489 index
= (index
+ step
) & (symtab
->size
- 1);
22493 /* Expand SYMTAB's hash table. */
22496 hash_expand (struct mapped_symtab
*symtab
)
22498 offset_type old_size
= symtab
->size
;
22500 struct symtab_index_entry
**old_entries
= symtab
->data
;
22503 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22505 for (i
= 0; i
< old_size
; ++i
)
22507 if (old_entries
[i
])
22509 struct symtab_index_entry
**slot
= find_slot (symtab
,
22510 old_entries
[i
]->name
);
22511 *slot
= old_entries
[i
];
22515 xfree (old_entries
);
22518 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22519 CU_INDEX is the index of the CU in which the symbol appears.
22520 IS_STATIC is one if the symbol is static, otherwise zero (global). */
22523 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
22524 int is_static
, gdb_index_symbol_kind kind
,
22525 offset_type cu_index
)
22527 struct symtab_index_entry
**slot
;
22528 offset_type cu_index_and_attrs
;
22530 ++symtab
->n_elements
;
22531 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
22532 hash_expand (symtab
);
22534 slot
= find_slot (symtab
, name
);
22537 *slot
= XNEW (struct symtab_index_entry
);
22538 (*slot
)->name
= name
;
22539 /* index_offset is set later. */
22540 (*slot
)->cu_indices
= NULL
;
22543 cu_index_and_attrs
= 0;
22544 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
22545 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
22546 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
22548 /* We don't want to record an index value twice as we want to avoid the
22550 We process all global symbols and then all static symbols
22551 (which would allow us to avoid the duplication by only having to check
22552 the last entry pushed), but a symbol could have multiple kinds in one CU.
22553 To keep things simple we don't worry about the duplication here and
22554 sort and uniqufy the list after we've processed all symbols. */
22555 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
22558 /* qsort helper routine for uniquify_cu_indices. */
22561 offset_type_compare (const void *ap
, const void *bp
)
22563 offset_type a
= *(offset_type
*) ap
;
22564 offset_type b
= *(offset_type
*) bp
;
22566 return (a
> b
) - (b
> a
);
22569 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22572 uniquify_cu_indices (struct mapped_symtab
*symtab
)
22576 for (i
= 0; i
< symtab
->size
; ++i
)
22578 struct symtab_index_entry
*entry
= symtab
->data
[i
];
22581 && entry
->cu_indices
!= NULL
)
22583 unsigned int next_to_insert
, next_to_check
;
22584 offset_type last_value
;
22586 qsort (VEC_address (offset_type
, entry
->cu_indices
),
22587 VEC_length (offset_type
, entry
->cu_indices
),
22588 sizeof (offset_type
), offset_type_compare
);
22590 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
22591 next_to_insert
= 1;
22592 for (next_to_check
= 1;
22593 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
22596 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
22599 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
22601 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
22606 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
22611 /* Add a vector of indices to the constant pool. */
22614 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
22615 struct symtab_index_entry
*entry
)
22619 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
22622 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
22623 offset_type val
= MAYBE_SWAP (len
);
22628 entry
->index_offset
= obstack_object_size (cpool
);
22630 obstack_grow (cpool
, &val
, sizeof (val
));
22632 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
22635 val
= MAYBE_SWAP (iter
);
22636 obstack_grow (cpool
, &val
, sizeof (val
));
22641 struct symtab_index_entry
*old_entry
= *slot
;
22642 entry
->index_offset
= old_entry
->index_offset
;
22645 return entry
->index_offset
;
22648 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22649 constant pool entries going into the obstack CPOOL. */
22652 write_hash_table (struct mapped_symtab
*symtab
,
22653 struct obstack
*output
, struct obstack
*cpool
)
22656 htab_t symbol_hash_table
;
22659 symbol_hash_table
= create_symbol_hash_table ();
22660 str_table
= create_strtab ();
22662 /* We add all the index vectors to the constant pool first, to
22663 ensure alignment is ok. */
22664 for (i
= 0; i
< symtab
->size
; ++i
)
22666 if (symtab
->data
[i
])
22667 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
22670 /* Now write out the hash table. */
22671 for (i
= 0; i
< symtab
->size
; ++i
)
22673 offset_type str_off
, vec_off
;
22675 if (symtab
->data
[i
])
22677 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
22678 vec_off
= symtab
->data
[i
]->index_offset
;
22682 /* While 0 is a valid constant pool index, it is not valid
22683 to have 0 for both offsets. */
22688 str_off
= MAYBE_SWAP (str_off
);
22689 vec_off
= MAYBE_SWAP (vec_off
);
22691 obstack_grow (output
, &str_off
, sizeof (str_off
));
22692 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
22695 htab_delete (str_table
);
22696 htab_delete (symbol_hash_table
);
22699 /* Struct to map psymtab to CU index in the index file. */
22700 struct psymtab_cu_index_map
22702 struct partial_symtab
*psymtab
;
22703 unsigned int cu_index
;
22707 hash_psymtab_cu_index (const void *item
)
22709 const struct psymtab_cu_index_map
*map
= item
;
22711 return htab_hash_pointer (map
->psymtab
);
22715 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
22717 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
22718 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
22720 return lhs
->psymtab
== rhs
->psymtab
;
22723 /* Helper struct for building the address table. */
22724 struct addrmap_index_data
22726 struct objfile
*objfile
;
22727 struct obstack
*addr_obstack
;
22728 htab_t cu_index_htab
;
22730 /* Non-zero if the previous_* fields are valid.
22731 We can't write an entry until we see the next entry (since it is only then
22732 that we know the end of the entry). */
22733 int previous_valid
;
22734 /* Index of the CU in the table of all CUs in the index file. */
22735 unsigned int previous_cu_index
;
22736 /* Start address of the CU. */
22737 CORE_ADDR previous_cu_start
;
22740 /* Write an address entry to OBSTACK. */
22743 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
22744 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
22746 offset_type cu_index_to_write
;
22748 CORE_ADDR baseaddr
;
22750 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
22752 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
22753 obstack_grow (obstack
, addr
, 8);
22754 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
22755 obstack_grow (obstack
, addr
, 8);
22756 cu_index_to_write
= MAYBE_SWAP (cu_index
);
22757 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
22760 /* Worker function for traversing an addrmap to build the address table. */
22763 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
22765 struct addrmap_index_data
*data
= datap
;
22766 struct partial_symtab
*pst
= obj
;
22768 if (data
->previous_valid
)
22769 add_address_entry (data
->objfile
, data
->addr_obstack
,
22770 data
->previous_cu_start
, start_addr
,
22771 data
->previous_cu_index
);
22773 data
->previous_cu_start
= start_addr
;
22776 struct psymtab_cu_index_map find_map
, *map
;
22777 find_map
.psymtab
= pst
;
22778 map
= htab_find (data
->cu_index_htab
, &find_map
);
22779 gdb_assert (map
!= NULL
);
22780 data
->previous_cu_index
= map
->cu_index
;
22781 data
->previous_valid
= 1;
22784 data
->previous_valid
= 0;
22789 /* Write OBJFILE's address map to OBSTACK.
22790 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22791 in the index file. */
22794 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
22795 htab_t cu_index_htab
)
22797 struct addrmap_index_data addrmap_index_data
;
22799 /* When writing the address table, we have to cope with the fact that
22800 the addrmap iterator only provides the start of a region; we have to
22801 wait until the next invocation to get the start of the next region. */
22803 addrmap_index_data
.objfile
= objfile
;
22804 addrmap_index_data
.addr_obstack
= obstack
;
22805 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
22806 addrmap_index_data
.previous_valid
= 0;
22808 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
22809 &addrmap_index_data
);
22811 /* It's highly unlikely the last entry (end address = 0xff...ff)
22812 is valid, but we should still handle it.
22813 The end address is recorded as the start of the next region, but that
22814 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22816 if (addrmap_index_data
.previous_valid
)
22817 add_address_entry (objfile
, obstack
,
22818 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
22819 addrmap_index_data
.previous_cu_index
);
22822 /* Return the symbol kind of PSYM. */
22824 static gdb_index_symbol_kind
22825 symbol_kind (struct partial_symbol
*psym
)
22827 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
22828 enum address_class aclass
= PSYMBOL_CLASS (psym
);
22836 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
22838 return GDB_INDEX_SYMBOL_KIND_TYPE
;
22840 case LOC_CONST_BYTES
:
22841 case LOC_OPTIMIZED_OUT
:
22843 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
22845 /* Note: It's currently impossible to recognize psyms as enum values
22846 short of reading the type info. For now punt. */
22847 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
22849 /* There are other LOC_FOO values that one might want to classify
22850 as variables, but dwarf2read.c doesn't currently use them. */
22851 return GDB_INDEX_SYMBOL_KIND_OTHER
;
22853 case STRUCT_DOMAIN
:
22854 return GDB_INDEX_SYMBOL_KIND_TYPE
;
22856 return GDB_INDEX_SYMBOL_KIND_OTHER
;
22860 /* Add a list of partial symbols to SYMTAB. */
22863 write_psymbols (struct mapped_symtab
*symtab
,
22865 struct partial_symbol
**psymp
,
22867 offset_type cu_index
,
22870 for (; count
-- > 0; ++psymp
)
22872 struct partial_symbol
*psym
= *psymp
;
22875 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
22876 error (_("Ada is not currently supported by the index"));
22878 /* Only add a given psymbol once. */
22879 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
22882 gdb_index_symbol_kind kind
= symbol_kind (psym
);
22885 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
22886 is_static
, kind
, cu_index
);
22891 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
22892 exception if there is an error. */
22895 write_obstack (FILE *file
, struct obstack
*obstack
)
22897 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
22899 != obstack_object_size (obstack
))
22900 error (_("couldn't data write to file"));
22903 /* Unlink a file if the argument is not NULL. */
22906 unlink_if_set (void *p
)
22908 char **filename
= p
;
22910 unlink (*filename
);
22913 /* A helper struct used when iterating over debug_types. */
22914 struct signatured_type_index_data
22916 struct objfile
*objfile
;
22917 struct mapped_symtab
*symtab
;
22918 struct obstack
*types_list
;
22923 /* A helper function that writes a single signatured_type to an
22927 write_one_signatured_type (void **slot
, void *d
)
22929 struct signatured_type_index_data
*info
= d
;
22930 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
22931 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
22934 write_psymbols (info
->symtab
,
22936 info
->objfile
->global_psymbols
.list
22937 + psymtab
->globals_offset
,
22938 psymtab
->n_global_syms
, info
->cu_index
,
22940 write_psymbols (info
->symtab
,
22942 info
->objfile
->static_psymbols
.list
22943 + psymtab
->statics_offset
,
22944 psymtab
->n_static_syms
, info
->cu_index
,
22947 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
22948 entry
->per_cu
.offset
.sect_off
);
22949 obstack_grow (info
->types_list
, val
, 8);
22950 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
22951 entry
->type_offset_in_tu
.cu_off
);
22952 obstack_grow (info
->types_list
, val
, 8);
22953 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
22954 obstack_grow (info
->types_list
, val
, 8);
22961 /* Recurse into all "included" dependencies and write their symbols as
22962 if they appeared in this psymtab. */
22965 recursively_write_psymbols (struct objfile
*objfile
,
22966 struct partial_symtab
*psymtab
,
22967 struct mapped_symtab
*symtab
,
22969 offset_type cu_index
)
22973 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
22974 if (psymtab
->dependencies
[i
]->user
!= NULL
)
22975 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
22976 symtab
, psyms_seen
, cu_index
);
22978 write_psymbols (symtab
,
22980 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
22981 psymtab
->n_global_syms
, cu_index
,
22983 write_psymbols (symtab
,
22985 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
22986 psymtab
->n_static_syms
, cu_index
,
22990 /* Create an index file for OBJFILE in the directory DIR. */
22993 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
22995 struct cleanup
*cleanup
;
22996 char *filename
, *cleanup_filename
;
22997 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
22998 struct obstack cu_list
, types_cu_list
;
23001 struct mapped_symtab
*symtab
;
23002 offset_type val
, size_of_contents
, total_len
;
23005 htab_t cu_index_htab
;
23006 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
23008 if (dwarf2_per_objfile
->using_index
)
23009 error (_("Cannot use an index to create the index"));
23011 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
23012 error (_("Cannot make an index when the file has multiple .debug_types sections"));
23014 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
23017 if (stat (objfile_name (objfile
), &st
) < 0)
23018 perror_with_name (objfile_name (objfile
));
23020 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile_name (objfile
)),
23021 INDEX_SUFFIX
, (char *) NULL
);
23022 cleanup
= make_cleanup (xfree
, filename
);
23024 out_file
= gdb_fopen_cloexec (filename
, "wb");
23026 error (_("Can't open `%s' for writing"), filename
);
23028 cleanup_filename
= filename
;
23029 make_cleanup (unlink_if_set
, &cleanup_filename
);
23031 symtab
= create_mapped_symtab ();
23032 make_cleanup (cleanup_mapped_symtab
, symtab
);
23034 obstack_init (&addr_obstack
);
23035 make_cleanup_obstack_free (&addr_obstack
);
23037 obstack_init (&cu_list
);
23038 make_cleanup_obstack_free (&cu_list
);
23040 obstack_init (&types_cu_list
);
23041 make_cleanup_obstack_free (&types_cu_list
);
23043 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
23044 NULL
, xcalloc
, xfree
);
23045 make_cleanup_htab_delete (psyms_seen
);
23047 /* While we're scanning CU's create a table that maps a psymtab pointer
23048 (which is what addrmap records) to its index (which is what is recorded
23049 in the index file). This will later be needed to write the address
23051 cu_index_htab
= htab_create_alloc (100,
23052 hash_psymtab_cu_index
,
23053 eq_psymtab_cu_index
,
23054 NULL
, xcalloc
, xfree
);
23055 make_cleanup_htab_delete (cu_index_htab
);
23056 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
23057 xmalloc (sizeof (struct psymtab_cu_index_map
)
23058 * dwarf2_per_objfile
->n_comp_units
);
23059 make_cleanup (xfree
, psymtab_cu_index_map
);
23061 /* The CU list is already sorted, so we don't need to do additional
23062 work here. Also, the debug_types entries do not appear in
23063 all_comp_units, but only in their own hash table. */
23064 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
23066 struct dwarf2_per_cu_data
*per_cu
23067 = dwarf2_per_objfile
->all_comp_units
[i
];
23068 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
23070 struct psymtab_cu_index_map
*map
;
23073 /* CU of a shared file from 'dwz -m' may be unused by this main file.
23074 It may be referenced from a local scope but in such case it does not
23075 need to be present in .gdb_index. */
23076 if (psymtab
== NULL
)
23079 if (psymtab
->user
== NULL
)
23080 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
23082 map
= &psymtab_cu_index_map
[i
];
23083 map
->psymtab
= psymtab
;
23085 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
23086 gdb_assert (slot
!= NULL
);
23087 gdb_assert (*slot
== NULL
);
23090 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23091 per_cu
->offset
.sect_off
);
23092 obstack_grow (&cu_list
, val
, 8);
23093 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
23094 obstack_grow (&cu_list
, val
, 8);
23097 /* Dump the address map. */
23098 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
23100 /* Write out the .debug_type entries, if any. */
23101 if (dwarf2_per_objfile
->signatured_types
)
23103 struct signatured_type_index_data sig_data
;
23105 sig_data
.objfile
= objfile
;
23106 sig_data
.symtab
= symtab
;
23107 sig_data
.types_list
= &types_cu_list
;
23108 sig_data
.psyms_seen
= psyms_seen
;
23109 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
23110 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
23111 write_one_signatured_type
, &sig_data
);
23114 /* Now that we've processed all symbols we can shrink their cu_indices
23116 uniquify_cu_indices (symtab
);
23118 obstack_init (&constant_pool
);
23119 make_cleanup_obstack_free (&constant_pool
);
23120 obstack_init (&symtab_obstack
);
23121 make_cleanup_obstack_free (&symtab_obstack
);
23122 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
23124 obstack_init (&contents
);
23125 make_cleanup_obstack_free (&contents
);
23126 size_of_contents
= 6 * sizeof (offset_type
);
23127 total_len
= size_of_contents
;
23129 /* The version number. */
23130 val
= MAYBE_SWAP (8);
23131 obstack_grow (&contents
, &val
, sizeof (val
));
23133 /* The offset of the CU list from the start of the file. */
23134 val
= MAYBE_SWAP (total_len
);
23135 obstack_grow (&contents
, &val
, sizeof (val
));
23136 total_len
+= obstack_object_size (&cu_list
);
23138 /* The offset of the types CU list from the start of the file. */
23139 val
= MAYBE_SWAP (total_len
);
23140 obstack_grow (&contents
, &val
, sizeof (val
));
23141 total_len
+= obstack_object_size (&types_cu_list
);
23143 /* The offset of the address table from the start of the file. */
23144 val
= MAYBE_SWAP (total_len
);
23145 obstack_grow (&contents
, &val
, sizeof (val
));
23146 total_len
+= obstack_object_size (&addr_obstack
);
23148 /* The offset of the symbol table from the start of the file. */
23149 val
= MAYBE_SWAP (total_len
);
23150 obstack_grow (&contents
, &val
, sizeof (val
));
23151 total_len
+= obstack_object_size (&symtab_obstack
);
23153 /* The offset of the constant pool from the start of the file. */
23154 val
= MAYBE_SWAP (total_len
);
23155 obstack_grow (&contents
, &val
, sizeof (val
));
23156 total_len
+= obstack_object_size (&constant_pool
);
23158 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
23160 write_obstack (out_file
, &contents
);
23161 write_obstack (out_file
, &cu_list
);
23162 write_obstack (out_file
, &types_cu_list
);
23163 write_obstack (out_file
, &addr_obstack
);
23164 write_obstack (out_file
, &symtab_obstack
);
23165 write_obstack (out_file
, &constant_pool
);
23169 /* We want to keep the file, so we set cleanup_filename to NULL
23170 here. See unlink_if_set. */
23171 cleanup_filename
= NULL
;
23173 do_cleanups (cleanup
);
23176 /* Implementation of the `save gdb-index' command.
23178 Note that the file format used by this command is documented in the
23179 GDB manual. Any changes here must be documented there. */
23182 save_gdb_index_command (char *arg
, int from_tty
)
23184 struct objfile
*objfile
;
23187 error (_("usage: save gdb-index DIRECTORY"));
23189 ALL_OBJFILES (objfile
)
23193 /* If the objfile does not correspond to an actual file, skip it. */
23194 if (stat (objfile_name (objfile
), &st
) < 0)
23197 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
23198 if (dwarf2_per_objfile
)
23203 write_psymtabs_to_index (objfile
, arg
);
23205 CATCH (except
, RETURN_MASK_ERROR
)
23207 exception_fprintf (gdb_stderr
, except
,
23208 _("Error while writing index for `%s': "),
23209 objfile_name (objfile
));
23218 int dwarf2_always_disassemble
;
23221 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
23222 struct cmd_list_element
*c
, const char *value
)
23224 fprintf_filtered (file
,
23225 _("Whether to always disassemble "
23226 "DWARF expressions is %s.\n"),
23231 show_check_physname (struct ui_file
*file
, int from_tty
,
23232 struct cmd_list_element
*c
, const char *value
)
23234 fprintf_filtered (file
,
23235 _("Whether to check \"physname\" is %s.\n"),
23239 void _initialize_dwarf2_read (void);
23242 _initialize_dwarf2_read (void)
23244 struct cmd_list_element
*c
;
23246 dwarf2_objfile_data_key
23247 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
23249 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
23250 Set DWARF 2 specific variables.\n\
23251 Configure DWARF 2 variables such as the cache size"),
23252 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
23253 0/*allow-unknown*/, &maintenance_set_cmdlist
);
23255 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
23256 Show DWARF 2 specific variables\n\
23257 Show DWARF 2 variables such as the cache size"),
23258 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
23259 0/*allow-unknown*/, &maintenance_show_cmdlist
);
23261 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
23262 &dwarf2_max_cache_age
, _("\
23263 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
23264 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
23265 A higher limit means that cached compilation units will be stored\n\
23266 in memory longer, and more total memory will be used. Zero disables\n\
23267 caching, which can slow down startup."),
23269 show_dwarf2_max_cache_age
,
23270 &set_dwarf2_cmdlist
,
23271 &show_dwarf2_cmdlist
);
23273 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
23274 &dwarf2_always_disassemble
, _("\
23275 Set whether `info address' always disassembles DWARF expressions."), _("\
23276 Show whether `info address' always disassembles DWARF expressions."), _("\
23277 When enabled, DWARF expressions are always printed in an assembly-like\n\
23278 syntax. When disabled, expressions will be printed in a more\n\
23279 conversational style, when possible."),
23281 show_dwarf2_always_disassemble
,
23282 &set_dwarf2_cmdlist
,
23283 &show_dwarf2_cmdlist
);
23285 add_setshow_zuinteger_cmd ("dwarf2-read", no_class
, &dwarf2_read_debug
, _("\
23286 Set debugging of the dwarf2 reader."), _("\
23287 Show debugging of the dwarf2 reader."), _("\
23288 When enabled (non-zero), debugging messages are printed during dwarf2\n\
23289 reading and symtab expansion. A value of 1 (one) provides basic\n\
23290 information. A value greater than 1 provides more verbose information."),
23293 &setdebuglist
, &showdebuglist
);
23295 add_setshow_zuinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
23296 Set debugging of the dwarf2 DIE reader."), _("\
23297 Show debugging of the dwarf2 DIE reader."), _("\
23298 When enabled (non-zero), DIEs are dumped after they are read in.\n\
23299 The value is the maximum depth to print."),
23302 &setdebuglist
, &showdebuglist
);
23304 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
23305 Set cross-checking of \"physname\" code against demangler."), _("\
23306 Show cross-checking of \"physname\" code against demangler."), _("\
23307 When enabled, GDB's internal \"physname\" code is checked against\n\
23309 NULL
, show_check_physname
,
23310 &setdebuglist
, &showdebuglist
);
23312 add_setshow_boolean_cmd ("use-deprecated-index-sections",
23313 no_class
, &use_deprecated_index_sections
, _("\
23314 Set whether to use deprecated gdb_index sections."), _("\
23315 Show whether to use deprecated gdb_index sections."), _("\
23316 When enabled, deprecated .gdb_index sections are used anyway.\n\
23317 Normally they are ignored either because of a missing feature or\n\
23318 performance issue.\n\
23319 Warning: This option must be enabled before gdb reads the file."),
23322 &setlist
, &showlist
);
23324 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
23326 Save a gdb-index file.\n\
23327 Usage: save gdb-index DIRECTORY"),
23329 set_cmd_completer (c
, filename_completer
);
23331 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23332 &dwarf2_locexpr_funcs
);
23333 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23334 &dwarf2_loclist_funcs
);
23336 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23337 &dwarf2_block_frame_base_locexpr_funcs
);
23338 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23339 &dwarf2_block_frame_base_loclist_funcs
);