1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2014 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
40 #include "gdb-demangle.h"
41 #include "expression.h"
42 #include "filenames.h" /* for DOSish file names */
45 #include "complaints.h"
47 #include "dwarf2expr.h"
48 #include "dwarf2loc.h"
49 #include "cp-support.h"
55 #include "typeprint.h"
58 #include "exceptions.h"
60 #include "completer.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
71 #include "filestuff.h"
76 #include "gdb_assert.h"
77 #include <sys/types.h>
79 typedef struct symbol
*symbolp
;
82 /* When == 1, print basic high level tracing messages.
83 When > 1, be more verbose.
84 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
85 static unsigned int dwarf2_read_debug
= 0;
87 /* When non-zero, dump DIEs after they are read in. */
88 static unsigned int dwarf2_die_debug
= 0;
90 /* When non-zero, cross-check physname against demangler. */
91 static int check_physname
= 0;
93 /* When non-zero, do not reject deprecated .gdb_index sections. */
94 static int use_deprecated_index_sections
= 0;
96 static const struct objfile_data
*dwarf2_objfile_data_key
;
98 /* The "aclass" indices for various kinds of computed DWARF symbols. */
100 static int dwarf2_locexpr_index
;
101 static int dwarf2_loclist_index
;
102 static int dwarf2_locexpr_block_index
;
103 static int dwarf2_loclist_block_index
;
105 /* A descriptor for dwarf sections.
107 S.ASECTION, SIZE are typically initialized when the objfile is first
108 scanned. BUFFER, READIN are filled in later when the section is read.
109 If the section contained compressed data then SIZE is updated to record
110 the uncompressed size of the section.
112 DWP file format V2 introduces a wrinkle that is easiest to handle by
113 creating the concept of virtual sections contained within a real section.
114 In DWP V2 the sections of the input DWO files are concatenated together
115 into one section, but section offsets are kept relative to the original
117 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
118 the real section this "virtual" section is contained in, and BUFFER,SIZE
119 describe the virtual section. */
121 struct dwarf2_section_info
125 /* If this is a real section, the bfd section. */
127 /* If this is a virtual section, pointer to the containing ("real")
129 struct dwarf2_section_info
*containing_section
;
131 /* Pointer to section data, only valid if readin. */
132 const gdb_byte
*buffer
;
133 /* The size of the section, real or virtual. */
135 /* If this is a virtual section, the offset in the real section.
136 Only valid if is_virtual. */
137 bfd_size_type virtual_offset
;
138 /* True if we have tried to read this section. */
140 /* True if this is a virtual section, False otherwise.
141 This specifies which of s.asection and s.containing_section to use. */
145 typedef struct dwarf2_section_info dwarf2_section_info_def
;
146 DEF_VEC_O (dwarf2_section_info_def
);
148 /* All offsets in the index are of this type. It must be
149 architecture-independent. */
150 typedef uint32_t offset_type
;
152 DEF_VEC_I (offset_type
);
154 /* Ensure only legit values are used. */
155 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
157 gdb_assert ((unsigned int) (value) <= 1); \
158 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
161 /* Ensure only legit values are used. */
162 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
164 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
165 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
166 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
169 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
170 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
172 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
173 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
176 /* A description of the mapped index. The file format is described in
177 a comment by the code that writes the index. */
180 /* Index data format version. */
183 /* The total length of the buffer. */
186 /* A pointer to the address table data. */
187 const gdb_byte
*address_table
;
189 /* Size of the address table data in bytes. */
190 offset_type address_table_size
;
192 /* The symbol table, implemented as a hash table. */
193 const offset_type
*symbol_table
;
195 /* Size in slots, each slot is 2 offset_types. */
196 offset_type symbol_table_slots
;
198 /* A pointer to the constant pool. */
199 const char *constant_pool
;
202 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
203 DEF_VEC_P (dwarf2_per_cu_ptr
);
205 /* Collection of data recorded per objfile.
206 This hangs off of dwarf2_objfile_data_key. */
208 struct dwarf2_per_objfile
210 struct dwarf2_section_info info
;
211 struct dwarf2_section_info abbrev
;
212 struct dwarf2_section_info line
;
213 struct dwarf2_section_info loc
;
214 struct dwarf2_section_info macinfo
;
215 struct dwarf2_section_info macro
;
216 struct dwarf2_section_info str
;
217 struct dwarf2_section_info ranges
;
218 struct dwarf2_section_info addr
;
219 struct dwarf2_section_info frame
;
220 struct dwarf2_section_info eh_frame
;
221 struct dwarf2_section_info gdb_index
;
223 VEC (dwarf2_section_info_def
) *types
;
226 struct objfile
*objfile
;
228 /* Table of all the compilation units. This is used to locate
229 the target compilation unit of a particular reference. */
230 struct dwarf2_per_cu_data
**all_comp_units
;
232 /* The number of compilation units in ALL_COMP_UNITS. */
235 /* The number of .debug_types-related CUs. */
238 /* The .debug_types-related CUs (TUs).
239 This is stored in malloc space because we may realloc it. */
240 struct signatured_type
**all_type_units
;
242 /* The number of entries in all_type_unit_groups. */
243 int n_type_unit_groups
;
245 /* Table of type unit groups.
246 This exists to make it easy to iterate over all CUs and TU groups. */
247 struct type_unit_group
**all_type_unit_groups
;
249 /* Table of struct type_unit_group objects.
250 The hash key is the DW_AT_stmt_list value. */
251 htab_t type_unit_groups
;
253 /* A table mapping .debug_types signatures to its signatured_type entry.
254 This is NULL if the .debug_types section hasn't been read in yet. */
255 htab_t signatured_types
;
257 /* Type unit statistics, to see how well the scaling improvements
261 int nr_uniq_abbrev_tables
;
263 int nr_symtab_sharers
;
264 int nr_stmt_less_type_units
;
267 /* A chain of compilation units that are currently read in, so that
268 they can be freed later. */
269 struct dwarf2_per_cu_data
*read_in_chain
;
271 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
272 This is NULL if the table hasn't been allocated yet. */
275 /* Non-zero if we've check for whether there is a DWP file. */
278 /* The DWP file if there is one, or NULL. */
279 struct dwp_file
*dwp_file
;
281 /* The shared '.dwz' file, if one exists. This is used when the
282 original data was compressed using 'dwz -m'. */
283 struct dwz_file
*dwz_file
;
285 /* A flag indicating wether this objfile has a section loaded at a
287 int has_section_at_zero
;
289 /* True if we are using the mapped index,
290 or we are faking it for OBJF_READNOW's sake. */
291 unsigned char using_index
;
293 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
294 struct mapped_index
*index_table
;
296 /* When using index_table, this keeps track of all quick_file_names entries.
297 TUs typically share line table entries with a CU, so we maintain a
298 separate table of all line table entries to support the sharing.
299 Note that while there can be way more TUs than CUs, we've already
300 sorted all the TUs into "type unit groups", grouped by their
301 DW_AT_stmt_list value. Therefore the only sharing done here is with a
302 CU and its associated TU group if there is one. */
303 htab_t quick_file_names_table
;
305 /* Set during partial symbol reading, to prevent queueing of full
307 int reading_partial_symbols
;
309 /* Table mapping type DIEs to their struct type *.
310 This is NULL if not allocated yet.
311 The mapping is done via (CU/TU + DIE offset) -> type. */
312 htab_t die_type_hash
;
314 /* The CUs we recently read. */
315 VEC (dwarf2_per_cu_ptr
) *just_read_cus
;
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 using partial symbol tables, the 'psymtab' field is active.
619 Otherwise the 'quick' 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 primary 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 primary symtab. */
726 struct symtab
*primary_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
,
1027 /* The line number information for a compilation unit (found in the
1028 .debug_line section) begins with a "statement program header",
1029 which contains the following information. */
1032 unsigned int total_length
;
1033 unsigned short version
;
1034 unsigned int header_length
;
1035 unsigned char minimum_instruction_length
;
1036 unsigned char maximum_ops_per_instruction
;
1037 unsigned char default_is_stmt
;
1039 unsigned char line_range
;
1040 unsigned char opcode_base
;
1042 /* standard_opcode_lengths[i] is the number of operands for the
1043 standard opcode whose value is i. This means that
1044 standard_opcode_lengths[0] is unused, and the last meaningful
1045 element is standard_opcode_lengths[opcode_base - 1]. */
1046 unsigned char *standard_opcode_lengths
;
1048 /* The include_directories table. NOTE! These strings are not
1049 allocated with xmalloc; instead, they are pointers into
1050 debug_line_buffer. If you try to free them, `free' will get
1052 unsigned int num_include_dirs
, include_dirs_size
;
1053 const char **include_dirs
;
1055 /* The file_names table. NOTE! These strings are not allocated
1056 with xmalloc; instead, they are pointers into debug_line_buffer.
1057 Don't try to free them directly. */
1058 unsigned int num_file_names
, file_names_size
;
1062 unsigned int dir_index
;
1063 unsigned int mod_time
;
1064 unsigned int length
;
1065 int included_p
; /* Non-zero if referenced by the Line Number Program. */
1066 struct symtab
*symtab
; /* The associated symbol table, if any. */
1069 /* The start and end of the statement program following this
1070 header. These point into dwarf2_per_objfile->line_buffer. */
1071 const gdb_byte
*statement_program_start
, *statement_program_end
;
1074 /* When we construct a partial symbol table entry we only
1075 need this much information. */
1076 struct partial_die_info
1078 /* Offset of this DIE. */
1081 /* DWARF-2 tag for this DIE. */
1082 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1084 /* Assorted flags describing the data found in this DIE. */
1085 unsigned int has_children
: 1;
1086 unsigned int is_external
: 1;
1087 unsigned int is_declaration
: 1;
1088 unsigned int has_type
: 1;
1089 unsigned int has_specification
: 1;
1090 unsigned int has_pc_info
: 1;
1091 unsigned int may_be_inlined
: 1;
1093 /* Flag set if the SCOPE field of this structure has been
1095 unsigned int scope_set
: 1;
1097 /* Flag set if the DIE has a byte_size attribute. */
1098 unsigned int has_byte_size
: 1;
1100 /* Flag set if any of the DIE's children are template arguments. */
1101 unsigned int has_template_arguments
: 1;
1103 /* Flag set if fixup_partial_die has been called on this die. */
1104 unsigned int fixup_called
: 1;
1106 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1107 unsigned int is_dwz
: 1;
1109 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1110 unsigned int spec_is_dwz
: 1;
1112 /* The name of this DIE. Normally the value of DW_AT_name, but
1113 sometimes a default name for unnamed DIEs. */
1116 /* The linkage name, if present. */
1117 const char *linkage_name
;
1119 /* The scope to prepend to our children. This is generally
1120 allocated on the comp_unit_obstack, so will disappear
1121 when this compilation unit leaves the cache. */
1124 /* Some data associated with the partial DIE. The tag determines
1125 which field is live. */
1128 /* The location description associated with this DIE, if any. */
1129 struct dwarf_block
*locdesc
;
1130 /* The offset of an import, for DW_TAG_imported_unit. */
1134 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1138 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1139 DW_AT_sibling, if any. */
1140 /* NOTE: This member isn't strictly necessary, read_partial_die could
1141 return DW_AT_sibling values to its caller load_partial_dies. */
1142 const gdb_byte
*sibling
;
1144 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1145 DW_AT_specification (or DW_AT_abstract_origin or
1146 DW_AT_extension). */
1147 sect_offset spec_offset
;
1149 /* Pointers to this DIE's parent, first child, and next sibling,
1151 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
1154 /* This data structure holds the information of an abbrev. */
1157 unsigned int number
; /* number identifying abbrev */
1158 enum dwarf_tag tag
; /* dwarf tag */
1159 unsigned short has_children
; /* boolean */
1160 unsigned short num_attrs
; /* number of attributes */
1161 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1162 struct abbrev_info
*next
; /* next in chain */
1167 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1168 ENUM_BITFIELD(dwarf_form
) form
: 16;
1171 /* Size of abbrev_table.abbrev_hash_table. */
1172 #define ABBREV_HASH_SIZE 121
1174 /* Top level data structure to contain an abbreviation table. */
1178 /* Where the abbrev table came from.
1179 This is used as a sanity check when the table is used. */
1182 /* Storage for the abbrev table. */
1183 struct obstack abbrev_obstack
;
1185 /* Hash table of abbrevs.
1186 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1187 It could be statically allocated, but the previous code didn't so we
1189 struct abbrev_info
**abbrevs
;
1192 /* Attributes have a name and a value. */
1195 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1196 ENUM_BITFIELD(dwarf_form
) form
: 15;
1198 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1199 field should be in u.str (existing only for DW_STRING) but it is kept
1200 here for better struct attribute alignment. */
1201 unsigned int string_is_canonical
: 1;
1206 struct dwarf_block
*blk
;
1215 /* This data structure holds a complete die structure. */
1218 /* DWARF-2 tag for this DIE. */
1219 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1221 /* Number of attributes */
1222 unsigned char num_attrs
;
1224 /* True if we're presently building the full type name for the
1225 type derived from this DIE. */
1226 unsigned char building_fullname
: 1;
1228 /* True if this die is in process. PR 16581. */
1229 unsigned char in_process
: 1;
1232 unsigned int abbrev
;
1234 /* Offset in .debug_info or .debug_types section. */
1237 /* The dies in a compilation unit form an n-ary tree. PARENT
1238 points to this die's parent; CHILD points to the first child of
1239 this node; and all the children of a given node are chained
1240 together via their SIBLING fields. */
1241 struct die_info
*child
; /* Its first child, if any. */
1242 struct die_info
*sibling
; /* Its next sibling, if any. */
1243 struct die_info
*parent
; /* Its parent, if any. */
1245 /* An array of attributes, with NUM_ATTRS elements. There may be
1246 zero, but it's not common and zero-sized arrays are not
1247 sufficiently portable C. */
1248 struct attribute attrs
[1];
1251 /* Get at parts of an attribute structure. */
1253 #define DW_STRING(attr) ((attr)->u.str)
1254 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1255 #define DW_UNSND(attr) ((attr)->u.unsnd)
1256 #define DW_BLOCK(attr) ((attr)->u.blk)
1257 #define DW_SND(attr) ((attr)->u.snd)
1258 #define DW_ADDR(attr) ((attr)->u.addr)
1259 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1261 /* Blocks are a bunch of untyped bytes. */
1266 /* Valid only if SIZE is not zero. */
1267 const gdb_byte
*data
;
1270 #ifndef ATTR_ALLOC_CHUNK
1271 #define ATTR_ALLOC_CHUNK 4
1274 /* Allocate fields for structs, unions and enums in this size. */
1275 #ifndef DW_FIELD_ALLOC_CHUNK
1276 #define DW_FIELD_ALLOC_CHUNK 4
1279 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1280 but this would require a corresponding change in unpack_field_as_long
1282 static int bits_per_byte
= 8;
1284 /* The routines that read and process dies for a C struct or C++ class
1285 pass lists of data member fields and lists of member function fields
1286 in an instance of a field_info structure, as defined below. */
1289 /* List of data member and baseclasses fields. */
1292 struct nextfield
*next
;
1297 *fields
, *baseclasses
;
1299 /* Number of fields (including baseclasses). */
1302 /* Number of baseclasses. */
1305 /* Set if the accesibility of one of the fields is not public. */
1306 int non_public_fields
;
1308 /* Member function fields array, entries are allocated in the order they
1309 are encountered in the object file. */
1312 struct nextfnfield
*next
;
1313 struct fn_field fnfield
;
1317 /* Member function fieldlist array, contains name of possibly overloaded
1318 member function, number of overloaded member functions and a pointer
1319 to the head of the member function field chain. */
1324 struct nextfnfield
*head
;
1328 /* Number of entries in the fnfieldlists array. */
1331 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1332 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1333 struct typedef_field_list
1335 struct typedef_field field
;
1336 struct typedef_field_list
*next
;
1338 *typedef_field_list
;
1339 unsigned typedef_field_list_count
;
1342 /* One item on the queue of compilation units to read in full symbols
1344 struct dwarf2_queue_item
1346 struct dwarf2_per_cu_data
*per_cu
;
1347 enum language pretend_language
;
1348 struct dwarf2_queue_item
*next
;
1351 /* The current queue. */
1352 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1354 /* Loaded secondary compilation units are kept in memory until they
1355 have not been referenced for the processing of this many
1356 compilation units. Set this to zero to disable caching. Cache
1357 sizes of up to at least twenty will improve startup time for
1358 typical inter-CU-reference binaries, at an obvious memory cost. */
1359 static int dwarf2_max_cache_age
= 5;
1361 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
1362 struct cmd_list_element
*c
, const char *value
)
1364 fprintf_filtered (file
, _("The upper bound on the age of cached "
1365 "dwarf2 compilation units is %s.\n"),
1369 /* local function prototypes */
1371 static const char *get_section_name (const struct dwarf2_section_info
*);
1373 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1375 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1377 static void dwarf2_find_base_address (struct die_info
*die
,
1378 struct dwarf2_cu
*cu
);
1380 static struct partial_symtab
*create_partial_symtab
1381 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1383 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1385 static void scan_partial_symbols (struct partial_die_info
*,
1386 CORE_ADDR
*, CORE_ADDR
*,
1387 int, struct dwarf2_cu
*);
1389 static void add_partial_symbol (struct partial_die_info
*,
1390 struct dwarf2_cu
*);
1392 static void add_partial_namespace (struct partial_die_info
*pdi
,
1393 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1394 int need_pc
, struct dwarf2_cu
*cu
);
1396 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1397 CORE_ADDR
*highpc
, int need_pc
,
1398 struct dwarf2_cu
*cu
);
1400 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1401 struct dwarf2_cu
*cu
);
1403 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1404 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1405 int need_pc
, struct dwarf2_cu
*cu
);
1407 static void dwarf2_read_symtab (struct partial_symtab
*,
1410 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1412 static struct abbrev_info
*abbrev_table_lookup_abbrev
1413 (const struct abbrev_table
*, unsigned int);
1415 static struct abbrev_table
*abbrev_table_read_table
1416 (struct dwarf2_section_info
*, sect_offset
);
1418 static void abbrev_table_free (struct abbrev_table
*);
1420 static void abbrev_table_free_cleanup (void *);
1422 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1423 struct dwarf2_section_info
*);
1425 static void dwarf2_free_abbrev_table (void *);
1427 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1429 static struct partial_die_info
*load_partial_dies
1430 (const struct die_reader_specs
*, const gdb_byte
*, int);
1432 static const gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1433 struct partial_die_info
*,
1434 struct abbrev_info
*,
1438 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1439 struct dwarf2_cu
*);
1441 static void fixup_partial_die (struct partial_die_info
*,
1442 struct dwarf2_cu
*);
1444 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1445 struct attribute
*, struct attr_abbrev
*,
1448 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1450 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1452 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1454 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1456 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1458 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1461 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1463 static LONGEST read_checked_initial_length_and_offset
1464 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1465 unsigned int *, unsigned int *);
1467 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1468 const struct comp_unit_head
*,
1471 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1473 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1476 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1478 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1480 static const char *read_indirect_string (bfd
*, const gdb_byte
*,
1481 const struct comp_unit_head
*,
1484 static const char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1486 static ULONGEST
read_unsigned_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1488 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1490 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1494 static const char *read_str_index (const struct die_reader_specs
*reader
,
1495 ULONGEST str_index
);
1497 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1499 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1500 struct dwarf2_cu
*);
1502 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1505 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1506 struct dwarf2_cu
*cu
);
1508 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1510 static struct die_info
*die_specification (struct die_info
*die
,
1511 struct dwarf2_cu
**);
1513 static void free_line_header (struct line_header
*lh
);
1515 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1516 struct dwarf2_cu
*cu
);
1518 static void dwarf_decode_lines (struct line_header
*, const char *,
1519 struct dwarf2_cu
*, struct partial_symtab
*,
1522 static void dwarf2_start_subfile (const char *, const char *, const char *);
1524 static void dwarf2_start_symtab (struct dwarf2_cu
*,
1525 const char *, const char *, CORE_ADDR
);
1527 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1528 struct dwarf2_cu
*);
1530 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1531 struct dwarf2_cu
*, struct symbol
*);
1533 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1534 struct dwarf2_cu
*);
1536 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1539 struct obstack
*obstack
,
1540 struct dwarf2_cu
*cu
, LONGEST
*value
,
1541 const gdb_byte
**bytes
,
1542 struct dwarf2_locexpr_baton
**baton
);
1544 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1546 static int need_gnat_info (struct dwarf2_cu
*);
1548 static struct type
*die_descriptive_type (struct die_info
*,
1549 struct dwarf2_cu
*);
1551 static void set_descriptive_type (struct type
*, struct die_info
*,
1552 struct dwarf2_cu
*);
1554 static struct type
*die_containing_type (struct die_info
*,
1555 struct dwarf2_cu
*);
1557 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1558 struct dwarf2_cu
*);
1560 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1562 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1564 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1566 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1567 const char *suffix
, int physname
,
1568 struct dwarf2_cu
*cu
);
1570 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1572 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1574 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1576 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1578 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1580 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1581 struct dwarf2_cu
*, struct partial_symtab
*);
1583 static int dwarf2_get_pc_bounds (struct die_info
*,
1584 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1585 struct partial_symtab
*);
1587 static void get_scope_pc_bounds (struct die_info
*,
1588 CORE_ADDR
*, CORE_ADDR
*,
1589 struct dwarf2_cu
*);
1591 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1592 CORE_ADDR
, struct dwarf2_cu
*);
1594 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1595 struct dwarf2_cu
*);
1597 static void dwarf2_attach_fields_to_type (struct field_info
*,
1598 struct type
*, struct dwarf2_cu
*);
1600 static void dwarf2_add_member_fn (struct field_info
*,
1601 struct die_info
*, struct type
*,
1602 struct dwarf2_cu
*);
1604 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1606 struct dwarf2_cu
*);
1608 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1610 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1612 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1614 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1616 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1618 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1620 static struct type
*read_module_type (struct die_info
*die
,
1621 struct dwarf2_cu
*cu
);
1623 static const char *namespace_name (struct die_info
*die
,
1624 int *is_anonymous
, struct dwarf2_cu
*);
1626 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1628 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1630 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1631 struct dwarf2_cu
*);
1633 static struct die_info
*read_die_and_siblings_1
1634 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1637 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1638 const gdb_byte
*info_ptr
,
1639 const gdb_byte
**new_info_ptr
,
1640 struct die_info
*parent
);
1642 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1643 struct die_info
**, const gdb_byte
*,
1646 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1647 struct die_info
**, const gdb_byte
*,
1650 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1652 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1655 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1657 static const char *dwarf2_full_name (const char *name
,
1658 struct die_info
*die
,
1659 struct dwarf2_cu
*cu
);
1661 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1662 struct dwarf2_cu
*cu
);
1664 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1665 struct dwarf2_cu
**);
1667 static const char *dwarf_tag_name (unsigned int);
1669 static const char *dwarf_attr_name (unsigned int);
1671 static const char *dwarf_form_name (unsigned int);
1673 static char *dwarf_bool_name (unsigned int);
1675 static const char *dwarf_type_encoding_name (unsigned int);
1677 static struct die_info
*sibling_die (struct die_info
*);
1679 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1681 static void dump_die_for_error (struct die_info
*);
1683 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1686 /*static*/ void dump_die (struct die_info
*, int max_level
);
1688 static void store_in_ref_table (struct die_info
*,
1689 struct dwarf2_cu
*);
1691 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1693 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1695 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1696 const struct attribute
*,
1697 struct dwarf2_cu
**);
1699 static struct die_info
*follow_die_ref (struct die_info
*,
1700 const struct attribute
*,
1701 struct dwarf2_cu
**);
1703 static struct die_info
*follow_die_sig (struct die_info
*,
1704 const struct attribute
*,
1705 struct dwarf2_cu
**);
1707 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1708 struct dwarf2_cu
*);
1710 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1711 const struct attribute
*,
1712 struct dwarf2_cu
*);
1714 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1716 static void read_signatured_type (struct signatured_type
*);
1718 static struct type_unit_group
*get_type_unit_group
1719 (struct dwarf2_cu
*, const struct attribute
*);
1721 static void build_type_unit_groups (die_reader_func_ftype
*, void *);
1723 /* memory allocation interface */
1725 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1727 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1729 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int,
1732 static int attr_form_is_block (const struct attribute
*);
1734 static int attr_form_is_section_offset (const struct attribute
*);
1736 static int attr_form_is_constant (const struct attribute
*);
1738 static int attr_form_is_ref (const struct attribute
*);
1740 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1741 struct dwarf2_loclist_baton
*baton
,
1742 const struct attribute
*attr
);
1744 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1746 struct dwarf2_cu
*cu
,
1749 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1750 const gdb_byte
*info_ptr
,
1751 struct abbrev_info
*abbrev
);
1753 static void free_stack_comp_unit (void *);
1755 static hashval_t
partial_die_hash (const void *item
);
1757 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1759 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1760 (sect_offset offset
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
1762 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1763 struct dwarf2_per_cu_data
*per_cu
);
1765 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1766 struct die_info
*comp_unit_die
,
1767 enum language pretend_language
);
1769 static void free_heap_comp_unit (void *);
1771 static void free_cached_comp_units (void *);
1773 static void age_cached_comp_units (void);
1775 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1777 static struct type
*set_die_type (struct die_info
*, struct type
*,
1778 struct dwarf2_cu
*);
1780 static void create_all_comp_units (struct objfile
*);
1782 static int create_all_type_units (struct objfile
*);
1784 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1787 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1790 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1793 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1794 struct dwarf2_per_cu_data
*);
1796 static void dwarf2_mark (struct dwarf2_cu
*);
1798 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1800 static struct type
*get_die_type_at_offset (sect_offset
,
1801 struct dwarf2_per_cu_data
*);
1803 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1805 static void dwarf2_release_queue (void *dummy
);
1807 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1808 enum language pretend_language
);
1810 static void process_queue (void);
1812 static void find_file_and_directory (struct die_info
*die
,
1813 struct dwarf2_cu
*cu
,
1814 const char **name
, const char **comp_dir
);
1816 static char *file_full_name (int file
, struct line_header
*lh
,
1817 const char *comp_dir
);
1819 static const gdb_byte
*read_and_check_comp_unit_head
1820 (struct comp_unit_head
*header
,
1821 struct dwarf2_section_info
*section
,
1822 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1823 int is_debug_types_section
);
1825 static void init_cutu_and_read_dies
1826 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1827 int use_existing_cu
, int keep
,
1828 die_reader_func_ftype
*die_reader_func
, void *data
);
1830 static void init_cutu_and_read_dies_simple
1831 (struct dwarf2_per_cu_data
*this_cu
,
1832 die_reader_func_ftype
*die_reader_func
, void *data
);
1834 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1836 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1838 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1839 (struct dwp_file
*dwp_file
, const char *comp_dir
,
1840 ULONGEST signature
, int is_debug_types
);
1842 static struct dwp_file
*get_dwp_file (void);
1844 static struct dwo_unit
*lookup_dwo_comp_unit
1845 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1847 static struct dwo_unit
*lookup_dwo_type_unit
1848 (struct signatured_type
*, const char *, const char *);
1850 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
1852 static void free_dwo_file_cleanup (void *);
1854 static void process_cu_includes (void);
1856 static void check_producer (struct dwarf2_cu
*cu
);
1858 /* Various complaints about symbol reading that don't abort the process. */
1861 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1863 complaint (&symfile_complaints
,
1864 _("statement list doesn't fit in .debug_line section"));
1868 dwarf2_debug_line_missing_file_complaint (void)
1870 complaint (&symfile_complaints
,
1871 _(".debug_line section has line data without a file"));
1875 dwarf2_debug_line_missing_end_sequence_complaint (void)
1877 complaint (&symfile_complaints
,
1878 _(".debug_line section has line "
1879 "program sequence without an end"));
1883 dwarf2_complex_location_expr_complaint (void)
1885 complaint (&symfile_complaints
, _("location expression too complex"));
1889 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1892 complaint (&symfile_complaints
,
1893 _("const value length mismatch for '%s', got %d, expected %d"),
1898 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1900 complaint (&symfile_complaints
,
1901 _("debug info runs off end of %s section"
1903 get_section_name (section
),
1904 get_section_file_name (section
));
1908 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1910 complaint (&symfile_complaints
,
1911 _("macro debug info contains a "
1912 "malformed macro definition:\n`%s'"),
1917 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1919 complaint (&symfile_complaints
,
1920 _("invalid attribute class or form for '%s' in '%s'"),
1926 /* Convert VALUE between big- and little-endian. */
1928 byte_swap (offset_type value
)
1932 result
= (value
& 0xff) << 24;
1933 result
|= (value
& 0xff00) << 8;
1934 result
|= (value
& 0xff0000) >> 8;
1935 result
|= (value
& 0xff000000) >> 24;
1939 #define MAYBE_SWAP(V) byte_swap (V)
1942 #define MAYBE_SWAP(V) (V)
1943 #endif /* WORDS_BIGENDIAN */
1945 /* Read the given attribute value as an address, taking the attribute's
1946 form into account. */
1949 attr_value_as_address (struct attribute
*attr
)
1953 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_GNU_addr_index
)
1955 /* Aside from a few clearly defined exceptions, attributes that
1956 contain an address must always be in DW_FORM_addr form.
1957 Unfortunately, some compilers happen to be violating this
1958 requirement by encoding addresses using other forms, such
1959 as DW_FORM_data4 for example. For those broken compilers,
1960 we try to do our best, without any guarantee of success,
1961 to interpret the address correctly. It would also be nice
1962 to generate a complaint, but that would require us to maintain
1963 a list of legitimate cases where a non-address form is allowed,
1964 as well as update callers to pass in at least the CU's DWARF
1965 version. This is more overhead than what we're willing to
1966 expand for a pretty rare case. */
1967 addr
= DW_UNSND (attr
);
1970 addr
= DW_ADDR (attr
);
1975 /* The suffix for an index file. */
1976 #define INDEX_SUFFIX ".gdb-index"
1978 /* Try to locate the sections we need for DWARF 2 debugging
1979 information and return true if we have enough to do something.
1980 NAMES points to the dwarf2 section names, or is NULL if the standard
1981 ELF names are used. */
1984 dwarf2_has_info (struct objfile
*objfile
,
1985 const struct dwarf2_debug_sections
*names
)
1987 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1988 if (!dwarf2_per_objfile
)
1990 /* Initialize per-objfile state. */
1991 struct dwarf2_per_objfile
*data
1992 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1994 memset (data
, 0, sizeof (*data
));
1995 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1996 dwarf2_per_objfile
= data
;
1998 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
2000 dwarf2_per_objfile
->objfile
= objfile
;
2002 return (!dwarf2_per_objfile
->info
.is_virtual
2003 && dwarf2_per_objfile
->info
.s
.asection
!= NULL
2004 && !dwarf2_per_objfile
->abbrev
.is_virtual
2005 && dwarf2_per_objfile
->abbrev
.s
.asection
!= NULL
);
2008 /* Return the containing section of virtual section SECTION. */
2010 static struct dwarf2_section_info
*
2011 get_containing_section (const struct dwarf2_section_info
*section
)
2013 gdb_assert (section
->is_virtual
);
2014 return section
->s
.containing_section
;
2017 /* Return the bfd owner of SECTION. */
2020 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2022 if (section
->is_virtual
)
2024 section
= get_containing_section (section
);
2025 gdb_assert (!section
->is_virtual
);
2027 return section
->s
.asection
->owner
;
2030 /* Return the bfd section of SECTION.
2031 Returns NULL if the section is not present. */
2034 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2036 if (section
->is_virtual
)
2038 section
= get_containing_section (section
);
2039 gdb_assert (!section
->is_virtual
);
2041 return section
->s
.asection
;
2044 /* Return the name of SECTION. */
2047 get_section_name (const struct dwarf2_section_info
*section
)
2049 asection
*sectp
= get_section_bfd_section (section
);
2051 gdb_assert (sectp
!= NULL
);
2052 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2055 /* Return the name of the file SECTION is in. */
2058 get_section_file_name (const struct dwarf2_section_info
*section
)
2060 bfd
*abfd
= get_section_bfd_owner (section
);
2062 return bfd_get_filename (abfd
);
2065 /* Return the id of SECTION.
2066 Returns 0 if SECTION doesn't exist. */
2069 get_section_id (const struct dwarf2_section_info
*section
)
2071 asection
*sectp
= get_section_bfd_section (section
);
2078 /* Return the flags of SECTION.
2079 SECTION (or containing section if this is a virtual section) must exist. */
2082 get_section_flags (const struct dwarf2_section_info
*section
)
2084 asection
*sectp
= get_section_bfd_section (section
);
2086 gdb_assert (sectp
!= NULL
);
2087 return bfd_get_section_flags (sectp
->owner
, sectp
);
2090 /* When loading sections, we look either for uncompressed section or for
2091 compressed section names. */
2094 section_is_p (const char *section_name
,
2095 const struct dwarf2_section_names
*names
)
2097 if (names
->normal
!= NULL
2098 && strcmp (section_name
, names
->normal
) == 0)
2100 if (names
->compressed
!= NULL
2101 && strcmp (section_name
, names
->compressed
) == 0)
2106 /* This function is mapped across the sections and remembers the
2107 offset and size of each of the debugging sections we are interested
2111 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
2113 const struct dwarf2_debug_sections
*names
;
2114 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2117 names
= &dwarf2_elf_names
;
2119 names
= (const struct dwarf2_debug_sections
*) vnames
;
2121 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2124 else if (section_is_p (sectp
->name
, &names
->info
))
2126 dwarf2_per_objfile
->info
.s
.asection
= sectp
;
2127 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
2129 else if (section_is_p (sectp
->name
, &names
->abbrev
))
2131 dwarf2_per_objfile
->abbrev
.s
.asection
= sectp
;
2132 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
2134 else if (section_is_p (sectp
->name
, &names
->line
))
2136 dwarf2_per_objfile
->line
.s
.asection
= sectp
;
2137 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
2139 else if (section_is_p (sectp
->name
, &names
->loc
))
2141 dwarf2_per_objfile
->loc
.s
.asection
= sectp
;
2142 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
2144 else if (section_is_p (sectp
->name
, &names
->macinfo
))
2146 dwarf2_per_objfile
->macinfo
.s
.asection
= sectp
;
2147 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
2149 else if (section_is_p (sectp
->name
, &names
->macro
))
2151 dwarf2_per_objfile
->macro
.s
.asection
= sectp
;
2152 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
2154 else if (section_is_p (sectp
->name
, &names
->str
))
2156 dwarf2_per_objfile
->str
.s
.asection
= sectp
;
2157 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
2159 else if (section_is_p (sectp
->name
, &names
->addr
))
2161 dwarf2_per_objfile
->addr
.s
.asection
= sectp
;
2162 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
2164 else if (section_is_p (sectp
->name
, &names
->frame
))
2166 dwarf2_per_objfile
->frame
.s
.asection
= sectp
;
2167 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
2169 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
2171 dwarf2_per_objfile
->eh_frame
.s
.asection
= sectp
;
2172 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
2174 else if (section_is_p (sectp
->name
, &names
->ranges
))
2176 dwarf2_per_objfile
->ranges
.s
.asection
= sectp
;
2177 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
2179 else if (section_is_p (sectp
->name
, &names
->types
))
2181 struct dwarf2_section_info type_section
;
2183 memset (&type_section
, 0, sizeof (type_section
));
2184 type_section
.s
.asection
= sectp
;
2185 type_section
.size
= bfd_get_section_size (sectp
);
2187 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
2190 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
2192 dwarf2_per_objfile
->gdb_index
.s
.asection
= sectp
;
2193 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
2196 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
2197 && bfd_section_vma (abfd
, sectp
) == 0)
2198 dwarf2_per_objfile
->has_section_at_zero
= 1;
2201 /* A helper function that decides whether a section is empty,
2205 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2207 if (section
->is_virtual
)
2208 return section
->size
== 0;
2209 return section
->s
.asection
== NULL
|| section
->size
== 0;
2212 /* Read the contents of the section INFO.
2213 OBJFILE is the main object file, but not necessarily the file where
2214 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2216 If the section is compressed, uncompress it before returning. */
2219 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
2223 gdb_byte
*buf
, *retbuf
;
2227 info
->buffer
= NULL
;
2230 if (dwarf2_section_empty_p (info
))
2233 sectp
= get_section_bfd_section (info
);
2235 /* If this is a virtual section we need to read in the real one first. */
2236 if (info
->is_virtual
)
2238 struct dwarf2_section_info
*containing_section
=
2239 get_containing_section (info
);
2241 gdb_assert (sectp
!= NULL
);
2242 if ((sectp
->flags
& SEC_RELOC
) != 0)
2244 error (_("Dwarf Error: DWP format V2 with relocations is not"
2245 " supported in section %s [in module %s]"),
2246 get_section_name (info
), get_section_file_name (info
));
2248 dwarf2_read_section (objfile
, containing_section
);
2249 /* Other code should have already caught virtual sections that don't
2251 gdb_assert (info
->virtual_offset
+ info
->size
2252 <= containing_section
->size
);
2253 /* If the real section is empty or there was a problem reading the
2254 section we shouldn't get here. */
2255 gdb_assert (containing_section
->buffer
!= NULL
);
2256 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2260 /* If the section has relocations, we must read it ourselves.
2261 Otherwise we attach it to the BFD. */
2262 if ((sectp
->flags
& SEC_RELOC
) == 0)
2264 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2268 buf
= obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2271 /* When debugging .o files, we may need to apply relocations; see
2272 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2273 We never compress sections in .o files, so we only need to
2274 try this when the section is not compressed. */
2275 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2278 info
->buffer
= retbuf
;
2282 abfd
= get_section_bfd_owner (info
);
2283 gdb_assert (abfd
!= NULL
);
2285 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2286 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2288 error (_("Dwarf Error: Can't read DWARF data"
2289 " in section %s [in module %s]"),
2290 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2294 /* A helper function that returns the size of a section in a safe way.
2295 If you are positive that the section has been read before using the
2296 size, then it is safe to refer to the dwarf2_section_info object's
2297 "size" field directly. In other cases, you must call this
2298 function, because for compressed sections the size field is not set
2299 correctly until the section has been read. */
2301 static bfd_size_type
2302 dwarf2_section_size (struct objfile
*objfile
,
2303 struct dwarf2_section_info
*info
)
2306 dwarf2_read_section (objfile
, info
);
2310 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2314 dwarf2_get_section_info (struct objfile
*objfile
,
2315 enum dwarf2_section_enum sect
,
2316 asection
**sectp
, const gdb_byte
**bufp
,
2317 bfd_size_type
*sizep
)
2319 struct dwarf2_per_objfile
*data
2320 = objfile_data (objfile
, dwarf2_objfile_data_key
);
2321 struct dwarf2_section_info
*info
;
2323 /* We may see an objfile without any DWARF, in which case we just
2334 case DWARF2_DEBUG_FRAME
:
2335 info
= &data
->frame
;
2337 case DWARF2_EH_FRAME
:
2338 info
= &data
->eh_frame
;
2341 gdb_assert_not_reached ("unexpected section");
2344 dwarf2_read_section (objfile
, info
);
2346 *sectp
= get_section_bfd_section (info
);
2347 *bufp
= info
->buffer
;
2348 *sizep
= info
->size
;
2351 /* A helper function to find the sections for a .dwz file. */
2354 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2356 struct dwz_file
*dwz_file
= arg
;
2358 /* Note that we only support the standard ELF names, because .dwz
2359 is ELF-only (at the time of writing). */
2360 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2362 dwz_file
->abbrev
.s
.asection
= sectp
;
2363 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2365 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2367 dwz_file
->info
.s
.asection
= sectp
;
2368 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2370 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2372 dwz_file
->str
.s
.asection
= sectp
;
2373 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2375 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2377 dwz_file
->line
.s
.asection
= sectp
;
2378 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2380 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2382 dwz_file
->macro
.s
.asection
= sectp
;
2383 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2385 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2387 dwz_file
->gdb_index
.s
.asection
= sectp
;
2388 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2392 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2393 there is no .gnu_debugaltlink section in the file. Error if there
2394 is such a section but the file cannot be found. */
2396 static struct dwz_file
*
2397 dwarf2_get_dwz_file (void)
2401 struct cleanup
*cleanup
;
2402 const char *filename
;
2403 struct dwz_file
*result
;
2404 bfd_size_type buildid_len_arg
;
2408 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2409 return dwarf2_per_objfile
->dwz_file
;
2411 bfd_set_error (bfd_error_no_error
);
2412 data
= bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2413 &buildid_len_arg
, &buildid
);
2416 if (bfd_get_error () == bfd_error_no_error
)
2418 error (_("could not read '.gnu_debugaltlink' section: %s"),
2419 bfd_errmsg (bfd_get_error ()));
2421 cleanup
= make_cleanup (xfree
, data
);
2422 make_cleanup (xfree
, buildid
);
2424 buildid_len
= (size_t) buildid_len_arg
;
2426 filename
= (const char *) data
;
2427 if (!IS_ABSOLUTE_PATH (filename
))
2429 char *abs
= gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2432 make_cleanup (xfree
, abs
);
2433 abs
= ldirname (abs
);
2434 make_cleanup (xfree
, abs
);
2436 rel
= concat (abs
, SLASH_STRING
, filename
, (char *) NULL
);
2437 make_cleanup (xfree
, rel
);
2441 /* First try the file name given in the section. If that doesn't
2442 work, try to use the build-id instead. */
2443 dwz_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2444 if (dwz_bfd
!= NULL
)
2446 if (!build_id_verify (dwz_bfd
, buildid_len
, buildid
))
2448 gdb_bfd_unref (dwz_bfd
);
2453 if (dwz_bfd
== NULL
)
2454 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2456 if (dwz_bfd
== NULL
)
2457 error (_("could not find '.gnu_debugaltlink' file for %s"),
2458 objfile_name (dwarf2_per_objfile
->objfile
));
2460 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2462 result
->dwz_bfd
= dwz_bfd
;
2464 bfd_map_over_sections (dwz_bfd
, locate_dwz_sections
, result
);
2466 do_cleanups (cleanup
);
2468 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, dwz_bfd
);
2469 dwarf2_per_objfile
->dwz_file
= result
;
2473 /* DWARF quick_symbols_functions support. */
2475 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2476 unique line tables, so we maintain a separate table of all .debug_line
2477 derived entries to support the sharing.
2478 All the quick functions need is the list of file names. We discard the
2479 line_header when we're done and don't need to record it here. */
2480 struct quick_file_names
2482 /* The data used to construct the hash key. */
2483 struct stmt_list_hash hash
;
2485 /* The number of entries in file_names, real_names. */
2486 unsigned int num_file_names
;
2488 /* The file names from the line table, after being run through
2490 const char **file_names
;
2492 /* The file names from the line table after being run through
2493 gdb_realpath. These are computed lazily. */
2494 const char **real_names
;
2497 /* When using the index (and thus not using psymtabs), each CU has an
2498 object of this type. This is used to hold information needed by
2499 the various "quick" methods. */
2500 struct dwarf2_per_cu_quick_data
2502 /* The file table. This can be NULL if there was no file table
2503 or it's currently not read in.
2504 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2505 struct quick_file_names
*file_names
;
2507 /* The corresponding symbol table. This is NULL if symbols for this
2508 CU have not yet been read. */
2509 struct symtab
*symtab
;
2511 /* A temporary mark bit used when iterating over all CUs in
2512 expand_symtabs_matching. */
2513 unsigned int mark
: 1;
2515 /* True if we've tried to read the file table and found there isn't one.
2516 There will be no point in trying to read it again next time. */
2517 unsigned int no_file_data
: 1;
2520 /* Utility hash function for a stmt_list_hash. */
2523 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2527 if (stmt_list_hash
->dwo_unit
!= NULL
)
2528 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2529 v
+= stmt_list_hash
->line_offset
.sect_off
;
2533 /* Utility equality function for a stmt_list_hash. */
2536 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2537 const struct stmt_list_hash
*rhs
)
2539 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2541 if (lhs
->dwo_unit
!= NULL
2542 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2545 return lhs
->line_offset
.sect_off
== rhs
->line_offset
.sect_off
;
2548 /* Hash function for a quick_file_names. */
2551 hash_file_name_entry (const void *e
)
2553 const struct quick_file_names
*file_data
= e
;
2555 return hash_stmt_list_entry (&file_data
->hash
);
2558 /* Equality function for a quick_file_names. */
2561 eq_file_name_entry (const void *a
, const void *b
)
2563 const struct quick_file_names
*ea
= a
;
2564 const struct quick_file_names
*eb
= b
;
2566 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2569 /* Delete function for a quick_file_names. */
2572 delete_file_name_entry (void *e
)
2574 struct quick_file_names
*file_data
= e
;
2577 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2579 xfree ((void*) file_data
->file_names
[i
]);
2580 if (file_data
->real_names
)
2581 xfree ((void*) file_data
->real_names
[i
]);
2584 /* The space for the struct itself lives on objfile_obstack,
2585 so we don't free it here. */
2588 /* Create a quick_file_names hash table. */
2591 create_quick_file_names_table (unsigned int nr_initial_entries
)
2593 return htab_create_alloc (nr_initial_entries
,
2594 hash_file_name_entry
, eq_file_name_entry
,
2595 delete_file_name_entry
, xcalloc
, xfree
);
2598 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2599 have to be created afterwards. You should call age_cached_comp_units after
2600 processing PER_CU->CU. dw2_setup must have been already called. */
2603 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2605 if (per_cu
->is_debug_types
)
2606 load_full_type_unit (per_cu
);
2608 load_full_comp_unit (per_cu
, language_minimal
);
2610 gdb_assert (per_cu
->cu
!= NULL
);
2612 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2615 /* Read in the symbols for PER_CU. */
2618 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2620 struct cleanup
*back_to
;
2622 /* Skip type_unit_groups, reading the type units they contain
2623 is handled elsewhere. */
2624 if (IS_TYPE_UNIT_GROUP (per_cu
))
2627 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2629 if (dwarf2_per_objfile
->using_index
2630 ? per_cu
->v
.quick
->symtab
== NULL
2631 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2633 queue_comp_unit (per_cu
, language_minimal
);
2636 /* If we just loaded a CU from a DWO, and we're working with an index
2637 that may badly handle TUs, load all the TUs in that DWO as well.
2638 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2639 if (!per_cu
->is_debug_types
2640 && per_cu
->cu
->dwo_unit
!= NULL
2641 && dwarf2_per_objfile
->index_table
!= NULL
2642 && dwarf2_per_objfile
->index_table
->version
<= 7
2643 /* DWP files aren't supported yet. */
2644 && get_dwp_file () == NULL
)
2645 queue_and_load_all_dwo_tus (per_cu
);
2650 /* Age the cache, releasing compilation units that have not
2651 been used recently. */
2652 age_cached_comp_units ();
2654 do_cleanups (back_to
);
2657 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2658 the objfile from which this CU came. Returns the resulting symbol
2661 static struct symtab
*
2662 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2664 gdb_assert (dwarf2_per_objfile
->using_index
);
2665 if (!per_cu
->v
.quick
->symtab
)
2667 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2668 increment_reading_symtab ();
2669 dw2_do_instantiate_symtab (per_cu
);
2670 process_cu_includes ();
2671 do_cleanups (back_to
);
2673 return per_cu
->v
.quick
->symtab
;
2676 /* Return the CU given its index.
2678 This is intended for loops like:
2680 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2681 + dwarf2_per_objfile->n_type_units); ++i)
2683 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2689 static struct dwarf2_per_cu_data
*
2690 dw2_get_cu (int index
)
2692 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2694 index
-= dwarf2_per_objfile
->n_comp_units
;
2695 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
2696 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
2699 return dwarf2_per_objfile
->all_comp_units
[index
];
2702 /* Return the primary CU given its index.
2703 The difference between this function and dw2_get_cu is in the handling
2704 of type units (TUs). Here we return the type_unit_group object.
2706 This is intended for loops like:
2708 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2709 + dwarf2_per_objfile->n_type_unit_groups); ++i)
2711 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
2717 static struct dwarf2_per_cu_data
*
2718 dw2_get_primary_cu (int index
)
2720 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2722 index
-= dwarf2_per_objfile
->n_comp_units
;
2723 gdb_assert (index
< dwarf2_per_objfile
->n_type_unit_groups
);
2724 return &dwarf2_per_objfile
->all_type_unit_groups
[index
]->per_cu
;
2727 return dwarf2_per_objfile
->all_comp_units
[index
];
2730 /* A helper for create_cus_from_index that handles a given list of
2734 create_cus_from_index_list (struct objfile
*objfile
,
2735 const gdb_byte
*cu_list
, offset_type n_elements
,
2736 struct dwarf2_section_info
*section
,
2742 for (i
= 0; i
< n_elements
; i
+= 2)
2744 struct dwarf2_per_cu_data
*the_cu
;
2745 ULONGEST offset
, length
;
2747 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2748 offset
= extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2749 length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2752 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2753 struct dwarf2_per_cu_data
);
2754 the_cu
->offset
.sect_off
= offset
;
2755 the_cu
->length
= length
;
2756 the_cu
->objfile
= objfile
;
2757 the_cu
->section
= section
;
2758 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2759 struct dwarf2_per_cu_quick_data
);
2760 the_cu
->is_dwz
= is_dwz
;
2761 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
2765 /* Read the CU list from the mapped index, and use it to create all
2766 the CU objects for this objfile. */
2769 create_cus_from_index (struct objfile
*objfile
,
2770 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2771 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2773 struct dwz_file
*dwz
;
2775 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
2776 dwarf2_per_objfile
->all_comp_units
2777 = obstack_alloc (&objfile
->objfile_obstack
,
2778 dwarf2_per_objfile
->n_comp_units
2779 * sizeof (struct dwarf2_per_cu_data
*));
2781 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
2782 &dwarf2_per_objfile
->info
, 0, 0);
2784 if (dwz_elements
== 0)
2787 dwz
= dwarf2_get_dwz_file ();
2788 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
2789 cu_list_elements
/ 2);
2792 /* Create the signatured type hash table from the index. */
2795 create_signatured_type_table_from_index (struct objfile
*objfile
,
2796 struct dwarf2_section_info
*section
,
2797 const gdb_byte
*bytes
,
2798 offset_type elements
)
2801 htab_t sig_types_hash
;
2803 dwarf2_per_objfile
->n_type_units
= elements
/ 3;
2804 dwarf2_per_objfile
->all_type_units
2805 = xmalloc (dwarf2_per_objfile
->n_type_units
2806 * sizeof (struct signatured_type
*));
2808 sig_types_hash
= allocate_signatured_type_table (objfile
);
2810 for (i
= 0; i
< elements
; i
+= 3)
2812 struct signatured_type
*sig_type
;
2813 ULONGEST offset
, type_offset_in_tu
, signature
;
2816 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2817 offset
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2818 type_offset_in_tu
= extract_unsigned_integer (bytes
+ 8, 8,
2820 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2823 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2824 struct signatured_type
);
2825 sig_type
->signature
= signature
;
2826 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2827 sig_type
->per_cu
.is_debug_types
= 1;
2828 sig_type
->per_cu
.section
= section
;
2829 sig_type
->per_cu
.offset
.sect_off
= offset
;
2830 sig_type
->per_cu
.objfile
= objfile
;
2831 sig_type
->per_cu
.v
.quick
2832 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2833 struct dwarf2_per_cu_quick_data
);
2835 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2838 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
2841 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2844 /* Read the address map data from the mapped index, and use it to
2845 populate the objfile's psymtabs_addrmap. */
2848 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2850 const gdb_byte
*iter
, *end
;
2851 struct obstack temp_obstack
;
2852 struct addrmap
*mutable_map
;
2853 struct cleanup
*cleanup
;
2856 obstack_init (&temp_obstack
);
2857 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2858 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2860 iter
= index
->address_table
;
2861 end
= iter
+ index
->address_table_size
;
2863 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2867 ULONGEST hi
, lo
, cu_index
;
2868 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2870 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2872 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2877 complaint (&symfile_complaints
,
2878 _(".gdb_index address table has invalid range (%s - %s)"),
2879 hex_string (lo
), hex_string (hi
));
2883 if (cu_index
>= dwarf2_per_objfile
->n_comp_units
)
2885 complaint (&symfile_complaints
,
2886 _(".gdb_index address table has invalid CU number %u"),
2887 (unsigned) cu_index
);
2891 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2892 dw2_get_cu (cu_index
));
2895 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2896 &objfile
->objfile_obstack
);
2897 do_cleanups (cleanup
);
2900 /* The hash function for strings in the mapped index. This is the same as
2901 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2902 implementation. This is necessary because the hash function is tied to the
2903 format of the mapped index file. The hash values do not have to match with
2906 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2909 mapped_index_string_hash (int index_version
, const void *p
)
2911 const unsigned char *str
= (const unsigned char *) p
;
2915 while ((c
= *str
++) != 0)
2917 if (index_version
>= 5)
2919 r
= r
* 67 + c
- 113;
2925 /* Find a slot in the mapped index INDEX for the object named NAME.
2926 If NAME is found, set *VEC_OUT to point to the CU vector in the
2927 constant pool and return 1. If NAME cannot be found, return 0. */
2930 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2931 offset_type
**vec_out
)
2933 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2935 offset_type slot
, step
;
2936 int (*cmp
) (const char *, const char *);
2938 if (current_language
->la_language
== language_cplus
2939 || current_language
->la_language
== language_java
2940 || current_language
->la_language
== language_fortran
)
2942 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2944 const char *paren
= strchr (name
, '(');
2950 dup
= xmalloc (paren
- name
+ 1);
2951 memcpy (dup
, name
, paren
- name
);
2952 dup
[paren
- name
] = 0;
2954 make_cleanup (xfree
, dup
);
2959 /* Index version 4 did not support case insensitive searches. But the
2960 indices for case insensitive languages are built in lowercase, therefore
2961 simulate our NAME being searched is also lowercased. */
2962 hash
= mapped_index_string_hash ((index
->version
== 4
2963 && case_sensitivity
== case_sensitive_off
2964 ? 5 : index
->version
),
2967 slot
= hash
& (index
->symbol_table_slots
- 1);
2968 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2969 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2973 /* Convert a slot number to an offset into the table. */
2974 offset_type i
= 2 * slot
;
2976 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2978 do_cleanups (back_to
);
2982 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2983 if (!cmp (name
, str
))
2985 *vec_out
= (offset_type
*) (index
->constant_pool
2986 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2987 do_cleanups (back_to
);
2991 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2995 /* A helper function that reads the .gdb_index from SECTION and fills
2996 in MAP. FILENAME is the name of the file containing the section;
2997 it is used for error reporting. DEPRECATED_OK is nonzero if it is
2998 ok to use deprecated sections.
3000 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3001 out parameters that are filled in with information about the CU and
3002 TU lists in the section.
3004 Returns 1 if all went well, 0 otherwise. */
3007 read_index_from_section (struct objfile
*objfile
,
3008 const char *filename
,
3010 struct dwarf2_section_info
*section
,
3011 struct mapped_index
*map
,
3012 const gdb_byte
**cu_list
,
3013 offset_type
*cu_list_elements
,
3014 const gdb_byte
**types_list
,
3015 offset_type
*types_list_elements
)
3017 const gdb_byte
*addr
;
3018 offset_type version
;
3019 offset_type
*metadata
;
3022 if (dwarf2_section_empty_p (section
))
3025 /* Older elfutils strip versions could keep the section in the main
3026 executable while splitting it for the separate debug info file. */
3027 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
3030 dwarf2_read_section (objfile
, section
);
3032 addr
= section
->buffer
;
3033 /* Version check. */
3034 version
= MAYBE_SWAP (*(offset_type
*) addr
);
3035 /* Versions earlier than 3 emitted every copy of a psymbol. This
3036 causes the index to behave very poorly for certain requests. Version 3
3037 contained incomplete addrmap. So, it seems better to just ignore such
3041 static int warning_printed
= 0;
3042 if (!warning_printed
)
3044 warning (_("Skipping obsolete .gdb_index section in %s."),
3046 warning_printed
= 1;
3050 /* Index version 4 uses a different hash function than index version
3053 Versions earlier than 6 did not emit psymbols for inlined
3054 functions. Using these files will cause GDB not to be able to
3055 set breakpoints on inlined functions by name, so we ignore these
3056 indices unless the user has done
3057 "set use-deprecated-index-sections on". */
3058 if (version
< 6 && !deprecated_ok
)
3060 static int warning_printed
= 0;
3061 if (!warning_printed
)
3064 Skipping deprecated .gdb_index section in %s.\n\
3065 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3066 to use the section anyway."),
3068 warning_printed
= 1;
3072 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3073 of the TU (for symbols coming from TUs),
3074 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3075 Plus gold-generated indices can have duplicate entries for global symbols,
3076 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3077 These are just performance bugs, and we can't distinguish gdb-generated
3078 indices from gold-generated ones, so issue no warning here. */
3080 /* Indexes with higher version than the one supported by GDB may be no
3081 longer backward compatible. */
3085 map
->version
= version
;
3086 map
->total_size
= section
->size
;
3088 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3091 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3092 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3096 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3097 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3098 - MAYBE_SWAP (metadata
[i
]))
3102 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3103 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
3104 - MAYBE_SWAP (metadata
[i
]));
3107 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
3108 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
3109 - MAYBE_SWAP (metadata
[i
]))
3110 / (2 * sizeof (offset_type
)));
3113 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3119 /* Read the index file. If everything went ok, initialize the "quick"
3120 elements of all the CUs and return 1. Otherwise, return 0. */
3123 dwarf2_read_index (struct objfile
*objfile
)
3125 struct mapped_index local_map
, *map
;
3126 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3127 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3128 struct dwz_file
*dwz
;
3130 if (!read_index_from_section (objfile
, objfile_name (objfile
),
3131 use_deprecated_index_sections
,
3132 &dwarf2_per_objfile
->gdb_index
, &local_map
,
3133 &cu_list
, &cu_list_elements
,
3134 &types_list
, &types_list_elements
))
3137 /* Don't use the index if it's empty. */
3138 if (local_map
.symbol_table_slots
== 0)
3141 /* If there is a .dwz file, read it so we can get its CU list as
3143 dwz
= dwarf2_get_dwz_file ();
3146 struct mapped_index dwz_map
;
3147 const gdb_byte
*dwz_types_ignore
;
3148 offset_type dwz_types_elements_ignore
;
3150 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
3152 &dwz
->gdb_index
, &dwz_map
,
3153 &dwz_list
, &dwz_list_elements
,
3155 &dwz_types_elements_ignore
))
3157 warning (_("could not read '.gdb_index' section from %s; skipping"),
3158 bfd_get_filename (dwz
->dwz_bfd
));
3163 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
3166 if (types_list_elements
)
3168 struct dwarf2_section_info
*section
;
3170 /* We can only handle a single .debug_types when we have an
3172 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3175 section
= VEC_index (dwarf2_section_info_def
,
3176 dwarf2_per_objfile
->types
, 0);
3178 create_signatured_type_table_from_index (objfile
, section
, types_list
,
3179 types_list_elements
);
3182 create_addrmap_from_index (objfile
, &local_map
);
3184 map
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct mapped_index
));
3187 dwarf2_per_objfile
->index_table
= map
;
3188 dwarf2_per_objfile
->using_index
= 1;
3189 dwarf2_per_objfile
->quick_file_names_table
=
3190 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3195 /* A helper for the "quick" functions which sets the global
3196 dwarf2_per_objfile according to OBJFILE. */
3199 dw2_setup (struct objfile
*objfile
)
3201 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
3202 gdb_assert (dwarf2_per_objfile
);
3205 /* die_reader_func for dw2_get_file_names. */
3208 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3209 const gdb_byte
*info_ptr
,
3210 struct die_info
*comp_unit_die
,
3214 struct dwarf2_cu
*cu
= reader
->cu
;
3215 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3216 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3217 struct dwarf2_per_cu_data
*lh_cu
;
3218 struct line_header
*lh
;
3219 struct attribute
*attr
;
3221 const char *name
, *comp_dir
;
3223 struct quick_file_names
*qfn
;
3224 unsigned int line_offset
;
3226 gdb_assert (! this_cu
->is_debug_types
);
3228 /* Our callers never want to match partial units -- instead they
3229 will match the enclosing full CU. */
3230 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3232 this_cu
->v
.quick
->no_file_data
= 1;
3241 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3244 struct quick_file_names find_entry
;
3246 line_offset
= DW_UNSND (attr
);
3248 /* We may have already read in this line header (TU line header sharing).
3249 If we have we're done. */
3250 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3251 find_entry
.hash
.line_offset
.sect_off
= line_offset
;
3252 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3253 &find_entry
, INSERT
);
3256 lh_cu
->v
.quick
->file_names
= *slot
;
3260 lh
= dwarf_decode_line_header (line_offset
, cu
);
3264 lh_cu
->v
.quick
->no_file_data
= 1;
3268 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
3269 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3270 qfn
->hash
.line_offset
.sect_off
= line_offset
;
3271 gdb_assert (slot
!= NULL
);
3274 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
3276 qfn
->num_file_names
= lh
->num_file_names
;
3277 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
3278 lh
->num_file_names
* sizeof (char *));
3279 for (i
= 0; i
< lh
->num_file_names
; ++i
)
3280 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
3281 qfn
->real_names
= NULL
;
3283 free_line_header (lh
);
3285 lh_cu
->v
.quick
->file_names
= qfn
;
3288 /* A helper for the "quick" functions which attempts to read the line
3289 table for THIS_CU. */
3291 static struct quick_file_names
*
3292 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3294 /* This should never be called for TUs. */
3295 gdb_assert (! this_cu
->is_debug_types
);
3296 /* Nor type unit groups. */
3297 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3299 if (this_cu
->v
.quick
->file_names
!= NULL
)
3300 return this_cu
->v
.quick
->file_names
;
3301 /* If we know there is no line data, no point in looking again. */
3302 if (this_cu
->v
.quick
->no_file_data
)
3305 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3307 if (this_cu
->v
.quick
->no_file_data
)
3309 return this_cu
->v
.quick
->file_names
;
3312 /* A helper for the "quick" functions which computes and caches the
3313 real path for a given file name from the line table. */
3316 dw2_get_real_path (struct objfile
*objfile
,
3317 struct quick_file_names
*qfn
, int index
)
3319 if (qfn
->real_names
== NULL
)
3320 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3321 qfn
->num_file_names
, char *);
3323 if (qfn
->real_names
[index
] == NULL
)
3324 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
3326 return qfn
->real_names
[index
];
3329 static struct symtab
*
3330 dw2_find_last_source_symtab (struct objfile
*objfile
)
3334 dw2_setup (objfile
);
3335 index
= dwarf2_per_objfile
->n_comp_units
- 1;
3336 return dw2_instantiate_symtab (dw2_get_cu (index
));
3339 /* Traversal function for dw2_forget_cached_source_info. */
3342 dw2_free_cached_file_names (void **slot
, void *info
)
3344 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3346 if (file_data
->real_names
)
3350 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3352 xfree ((void*) file_data
->real_names
[i
]);
3353 file_data
->real_names
[i
] = NULL
;
3361 dw2_forget_cached_source_info (struct objfile
*objfile
)
3363 dw2_setup (objfile
);
3365 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3366 dw2_free_cached_file_names
, NULL
);
3369 /* Helper function for dw2_map_symtabs_matching_filename that expands
3370 the symtabs and calls the iterator. */
3373 dw2_map_expand_apply (struct objfile
*objfile
,
3374 struct dwarf2_per_cu_data
*per_cu
,
3375 const char *name
, const char *real_path
,
3376 int (*callback
) (struct symtab
*, void *),
3379 struct symtab
*last_made
= objfile
->symtabs
;
3381 /* Don't visit already-expanded CUs. */
3382 if (per_cu
->v
.quick
->symtab
)
3385 /* This may expand more than one symtab, and we want to iterate over
3387 dw2_instantiate_symtab (per_cu
);
3389 return iterate_over_some_symtabs (name
, real_path
, callback
, data
,
3390 objfile
->symtabs
, last_made
);
3393 /* Implementation of the map_symtabs_matching_filename method. */
3396 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
3397 const char *real_path
,
3398 int (*callback
) (struct symtab
*, void *),
3402 const char *name_basename
= lbasename (name
);
3404 dw2_setup (objfile
);
3406 /* The rule is CUs specify all the files, including those used by
3407 any TU, so there's no need to scan TUs here. */
3409 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3412 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3413 struct quick_file_names
*file_data
;
3415 /* We only need to look at symtabs not already expanded. */
3416 if (per_cu
->v
.quick
->symtab
)
3419 file_data
= dw2_get_file_names (per_cu
);
3420 if (file_data
== NULL
)
3423 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3425 const char *this_name
= file_data
->file_names
[j
];
3426 const char *this_real_name
;
3428 if (compare_filenames_for_search (this_name
, name
))
3430 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3436 /* Before we invoke realpath, which can get expensive when many
3437 files are involved, do a quick comparison of the basenames. */
3438 if (! basenames_may_differ
3439 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3442 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3443 if (compare_filenames_for_search (this_real_name
, name
))
3445 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3451 if (real_path
!= NULL
)
3453 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3454 gdb_assert (IS_ABSOLUTE_PATH (name
));
3455 if (this_real_name
!= NULL
3456 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3458 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3470 /* Struct used to manage iterating over all CUs looking for a symbol. */
3472 struct dw2_symtab_iterator
3474 /* The internalized form of .gdb_index. */
3475 struct mapped_index
*index
;
3476 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3477 int want_specific_block
;
3478 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3479 Unused if !WANT_SPECIFIC_BLOCK. */
3481 /* The kind of symbol we're looking for. */
3483 /* The list of CUs from the index entry of the symbol,
3484 or NULL if not found. */
3486 /* The next element in VEC to look at. */
3488 /* The number of elements in VEC, or zero if there is no match. */
3490 /* Have we seen a global version of the symbol?
3491 If so we can ignore all further global instances.
3492 This is to work around gold/15646, inefficient gold-generated
3497 /* Initialize the index symtab iterator ITER.
3498 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3499 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3502 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3503 struct mapped_index
*index
,
3504 int want_specific_block
,
3509 iter
->index
= index
;
3510 iter
->want_specific_block
= want_specific_block
;
3511 iter
->block_index
= block_index
;
3512 iter
->domain
= domain
;
3514 iter
->global_seen
= 0;
3516 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3517 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3525 /* Return the next matching CU or NULL if there are no more. */
3527 static struct dwarf2_per_cu_data
*
3528 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3530 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3532 offset_type cu_index_and_attrs
=
3533 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3534 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3535 struct dwarf2_per_cu_data
*per_cu
;
3536 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3537 /* This value is only valid for index versions >= 7. */
3538 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3539 gdb_index_symbol_kind symbol_kind
=
3540 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3541 /* Only check the symbol attributes if they're present.
3542 Indices prior to version 7 don't record them,
3543 and indices >= 7 may elide them for certain symbols
3544 (gold does this). */
3546 (iter
->index
->version
>= 7
3547 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3549 /* Don't crash on bad data. */
3550 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3551 + dwarf2_per_objfile
->n_type_units
))
3553 complaint (&symfile_complaints
,
3554 _(".gdb_index entry has bad CU index"
3556 objfile_name (dwarf2_per_objfile
->objfile
));
3560 per_cu
= dw2_get_cu (cu_index
);
3562 /* Skip if already read in. */
3563 if (per_cu
->v
.quick
->symtab
)
3566 /* Check static vs global. */
3569 if (iter
->want_specific_block
3570 && want_static
!= is_static
)
3572 /* Work around gold/15646. */
3573 if (!is_static
&& iter
->global_seen
)
3576 iter
->global_seen
= 1;
3579 /* Only check the symbol's kind if it has one. */
3582 switch (iter
->domain
)
3585 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3586 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3587 /* Some types are also in VAR_DOMAIN. */
3588 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3592 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3596 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3611 static struct symtab
*
3612 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3613 const char *name
, domain_enum domain
)
3615 struct symtab
*stab_best
= NULL
;
3616 struct mapped_index
*index
;
3618 dw2_setup (objfile
);
3620 index
= dwarf2_per_objfile
->index_table
;
3622 /* index is NULL if OBJF_READNOW. */
3625 struct dw2_symtab_iterator iter
;
3626 struct dwarf2_per_cu_data
*per_cu
;
3628 dw2_symtab_iter_init (&iter
, index
, 1, block_index
, domain
, name
);
3630 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3632 struct symbol
*sym
= NULL
;
3633 struct symtab
*stab
= dw2_instantiate_symtab (per_cu
);
3635 /* Some caution must be observed with overloaded functions
3636 and methods, since the index will not contain any overload
3637 information (but NAME might contain it). */
3640 struct blockvector
*bv
= BLOCKVECTOR (stab
);
3641 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3643 sym
= lookup_block_symbol (block
, name
, domain
);
3646 if (sym
&& strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
3648 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
3654 /* Keep looking through other CUs. */
3662 dw2_print_stats (struct objfile
*objfile
)
3664 int i
, total
, count
;
3666 dw2_setup (objfile
);
3667 total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
3669 for (i
= 0; i
< total
; ++i
)
3671 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3673 if (!per_cu
->v
.quick
->symtab
)
3676 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3677 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3680 /* This dumps minimal information about the index.
3681 It is called via "mt print objfiles".
3682 One use is to verify .gdb_index has been loaded by the
3683 gdb.dwarf2/gdb-index.exp testcase. */
3686 dw2_dump (struct objfile
*objfile
)
3688 dw2_setup (objfile
);
3689 gdb_assert (dwarf2_per_objfile
->using_index
);
3690 printf_filtered (".gdb_index:");
3691 if (dwarf2_per_objfile
->index_table
!= NULL
)
3693 printf_filtered (" version %d\n",
3694 dwarf2_per_objfile
->index_table
->version
);
3697 printf_filtered (" faked for \"readnow\"\n");
3698 printf_filtered ("\n");
3702 dw2_relocate (struct objfile
*objfile
,
3703 const struct section_offsets
*new_offsets
,
3704 const struct section_offsets
*delta
)
3706 /* There's nothing to relocate here. */
3710 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3711 const char *func_name
)
3713 struct mapped_index
*index
;
3715 dw2_setup (objfile
);
3717 index
= dwarf2_per_objfile
->index_table
;
3719 /* index is NULL if OBJF_READNOW. */
3722 struct dw2_symtab_iterator iter
;
3723 struct dwarf2_per_cu_data
*per_cu
;
3725 /* Note: It doesn't matter what we pass for block_index here. */
3726 dw2_symtab_iter_init (&iter
, index
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
3729 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3730 dw2_instantiate_symtab (per_cu
);
3735 dw2_expand_all_symtabs (struct objfile
*objfile
)
3739 dw2_setup (objfile
);
3741 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3742 + dwarf2_per_objfile
->n_type_units
); ++i
)
3744 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3746 dw2_instantiate_symtab (per_cu
);
3751 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3752 const char *fullname
)
3756 dw2_setup (objfile
);
3758 /* We don't need to consider type units here.
3759 This is only called for examining code, e.g. expand_line_sal.
3760 There can be an order of magnitude (or more) more type units
3761 than comp units, and we avoid them if we can. */
3763 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3766 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3767 struct quick_file_names
*file_data
;
3769 /* We only need to look at symtabs not already expanded. */
3770 if (per_cu
->v
.quick
->symtab
)
3773 file_data
= dw2_get_file_names (per_cu
);
3774 if (file_data
== NULL
)
3777 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3779 const char *this_fullname
= file_data
->file_names
[j
];
3781 if (filename_cmp (this_fullname
, fullname
) == 0)
3783 dw2_instantiate_symtab (per_cu
);
3791 dw2_map_matching_symbols (struct objfile
*objfile
,
3792 const char * name
, domain_enum
namespace,
3794 int (*callback
) (struct block
*,
3795 struct symbol
*, void *),
3796 void *data
, symbol_compare_ftype
*match
,
3797 symbol_compare_ftype
*ordered_compare
)
3799 /* Currently unimplemented; used for Ada. The function can be called if the
3800 current language is Ada for a non-Ada objfile using GNU index. As Ada
3801 does not look for non-Ada symbols this function should just return. */
3805 dw2_expand_symtabs_matching
3806 (struct objfile
*objfile
,
3807 expand_symtabs_file_matcher_ftype
*file_matcher
,
3808 expand_symtabs_symbol_matcher_ftype
*symbol_matcher
,
3809 enum search_domain kind
,
3814 struct mapped_index
*index
;
3816 dw2_setup (objfile
);
3818 /* index_table is NULL if OBJF_READNOW. */
3819 if (!dwarf2_per_objfile
->index_table
)
3821 index
= dwarf2_per_objfile
->index_table
;
3823 if (file_matcher
!= NULL
)
3825 struct cleanup
*cleanup
;
3826 htab_t visited_found
, visited_not_found
;
3828 visited_found
= htab_create_alloc (10,
3829 htab_hash_pointer
, htab_eq_pointer
,
3830 NULL
, xcalloc
, xfree
);
3831 cleanup
= make_cleanup_htab_delete (visited_found
);
3832 visited_not_found
= htab_create_alloc (10,
3833 htab_hash_pointer
, htab_eq_pointer
,
3834 NULL
, xcalloc
, xfree
);
3835 make_cleanup_htab_delete (visited_not_found
);
3837 /* The rule is CUs specify all the files, including those used by
3838 any TU, so there's no need to scan TUs here. */
3840 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3843 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3844 struct quick_file_names
*file_data
;
3847 per_cu
->v
.quick
->mark
= 0;
3849 /* We only need to look at symtabs not already expanded. */
3850 if (per_cu
->v
.quick
->symtab
)
3853 file_data
= dw2_get_file_names (per_cu
);
3854 if (file_data
== NULL
)
3857 if (htab_find (visited_not_found
, file_data
) != NULL
)
3859 else if (htab_find (visited_found
, file_data
) != NULL
)
3861 per_cu
->v
.quick
->mark
= 1;
3865 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3867 const char *this_real_name
;
3869 if (file_matcher (file_data
->file_names
[j
], data
, 0))
3871 per_cu
->v
.quick
->mark
= 1;
3875 /* Before we invoke realpath, which can get expensive when many
3876 files are involved, do a quick comparison of the basenames. */
3877 if (!basenames_may_differ
3878 && !file_matcher (lbasename (file_data
->file_names
[j
]),
3882 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3883 if (file_matcher (this_real_name
, data
, 0))
3885 per_cu
->v
.quick
->mark
= 1;
3890 slot
= htab_find_slot (per_cu
->v
.quick
->mark
3892 : visited_not_found
,
3897 do_cleanups (cleanup
);
3900 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
3902 offset_type idx
= 2 * iter
;
3904 offset_type
*vec
, vec_len
, vec_idx
;
3905 int global_seen
= 0;
3907 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
3910 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
3912 if (! (*symbol_matcher
) (name
, data
))
3915 /* The name was matched, now expand corresponding CUs that were
3917 vec
= (offset_type
*) (index
->constant_pool
3918 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
3919 vec_len
= MAYBE_SWAP (vec
[0]);
3920 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
3922 struct dwarf2_per_cu_data
*per_cu
;
3923 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
3924 /* This value is only valid for index versions >= 7. */
3925 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3926 gdb_index_symbol_kind symbol_kind
=
3927 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3928 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3929 /* Only check the symbol attributes if they're present.
3930 Indices prior to version 7 don't record them,
3931 and indices >= 7 may elide them for certain symbols
3932 (gold does this). */
3934 (index
->version
>= 7
3935 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3937 /* Work around gold/15646. */
3940 if (!is_static
&& global_seen
)
3946 /* Only check the symbol's kind if it has one. */
3951 case VARIABLES_DOMAIN
:
3952 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
3955 case FUNCTIONS_DOMAIN
:
3956 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
3960 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3968 /* Don't crash on bad data. */
3969 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3970 + dwarf2_per_objfile
->n_type_units
))
3972 complaint (&symfile_complaints
,
3973 _(".gdb_index entry has bad CU index"
3974 " [in module %s]"), objfile_name (objfile
));
3978 per_cu
= dw2_get_cu (cu_index
);
3979 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
3980 dw2_instantiate_symtab (per_cu
);
3985 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3988 static struct symtab
*
3989 recursively_find_pc_sect_symtab (struct symtab
*symtab
, CORE_ADDR pc
)
3993 if (BLOCKVECTOR (symtab
) != NULL
3994 && blockvector_contains_pc (BLOCKVECTOR (symtab
), pc
))
3997 if (symtab
->includes
== NULL
)
4000 for (i
= 0; symtab
->includes
[i
]; ++i
)
4002 struct symtab
*s
= symtab
->includes
[i
];
4004 s
= recursively_find_pc_sect_symtab (s
, pc
);
4012 static struct symtab
*
4013 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
4014 struct bound_minimal_symbol msymbol
,
4016 struct obj_section
*section
,
4019 struct dwarf2_per_cu_data
*data
;
4020 struct symtab
*result
;
4022 dw2_setup (objfile
);
4024 if (!objfile
->psymtabs_addrmap
)
4027 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
4031 if (warn_if_readin
&& data
->v
.quick
->symtab
)
4032 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4033 paddress (get_objfile_arch (objfile
), pc
));
4035 result
= recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data
), pc
);
4036 gdb_assert (result
!= NULL
);
4041 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4042 void *data
, int need_fullname
)
4045 struct cleanup
*cleanup
;
4046 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
4047 NULL
, xcalloc
, xfree
);
4049 cleanup
= make_cleanup_htab_delete (visited
);
4050 dw2_setup (objfile
);
4052 /* The rule is CUs specify all the files, including those used by
4053 any TU, so there's no need to scan TUs here.
4054 We can ignore file names coming from already-expanded CUs. */
4056 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4058 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4060 if (per_cu
->v
.quick
->symtab
)
4062 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
4065 *slot
= per_cu
->v
.quick
->file_names
;
4069 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4072 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
4073 struct quick_file_names
*file_data
;
4076 /* We only need to look at symtabs not already expanded. */
4077 if (per_cu
->v
.quick
->symtab
)
4080 file_data
= dw2_get_file_names (per_cu
);
4081 if (file_data
== NULL
)
4084 slot
= htab_find_slot (visited
, file_data
, INSERT
);
4087 /* Already visited. */
4092 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4094 const char *this_real_name
;
4097 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
4099 this_real_name
= NULL
;
4100 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
4104 do_cleanups (cleanup
);
4108 dw2_has_symbols (struct objfile
*objfile
)
4113 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4116 dw2_find_last_source_symtab
,
4117 dw2_forget_cached_source_info
,
4118 dw2_map_symtabs_matching_filename
,
4123 dw2_expand_symtabs_for_function
,
4124 dw2_expand_all_symtabs
,
4125 dw2_expand_symtabs_with_fullname
,
4126 dw2_map_matching_symbols
,
4127 dw2_expand_symtabs_matching
,
4128 dw2_find_pc_sect_symtab
,
4129 dw2_map_symbol_filenames
4132 /* Initialize for reading DWARF for this objfile. Return 0 if this
4133 file will use psymtabs, or 1 if using the GNU index. */
4136 dwarf2_initialize_objfile (struct objfile
*objfile
)
4138 /* If we're about to read full symbols, don't bother with the
4139 indices. In this case we also don't care if some other debug
4140 format is making psymtabs, because they are all about to be
4142 if ((objfile
->flags
& OBJF_READNOW
))
4146 dwarf2_per_objfile
->using_index
= 1;
4147 create_all_comp_units (objfile
);
4148 create_all_type_units (objfile
);
4149 dwarf2_per_objfile
->quick_file_names_table
=
4150 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
4152 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
4153 + dwarf2_per_objfile
->n_type_units
); ++i
)
4155 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4157 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4158 struct dwarf2_per_cu_quick_data
);
4161 /* Return 1 so that gdb sees the "quick" functions. However,
4162 these functions will be no-ops because we will have expanded
4167 if (dwarf2_read_index (objfile
))
4175 /* Build a partial symbol table. */
4178 dwarf2_build_psymtabs (struct objfile
*objfile
)
4180 volatile struct gdb_exception except
;
4182 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
4184 init_psymbol_list (objfile
, 1024);
4187 TRY_CATCH (except
, RETURN_MASK_ERROR
)
4189 /* This isn't really ideal: all the data we allocate on the
4190 objfile's obstack is still uselessly kept around. However,
4191 freeing it seems unsafe. */
4192 struct cleanup
*cleanups
= make_cleanup_discard_psymtabs (objfile
);
4194 dwarf2_build_psymtabs_hard (objfile
);
4195 discard_cleanups (cleanups
);
4197 if (except
.reason
< 0)
4198 exception_print (gdb_stderr
, except
);
4201 /* Return the total length of the CU described by HEADER. */
4204 get_cu_length (const struct comp_unit_head
*header
)
4206 return header
->initial_length_size
+ header
->length
;
4209 /* Return TRUE if OFFSET is within CU_HEADER. */
4212 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
4214 sect_offset bottom
= { cu_header
->offset
.sect_off
};
4215 sect_offset top
= { cu_header
->offset
.sect_off
+ get_cu_length (cu_header
) };
4217 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
4220 /* Find the base address of the compilation unit for range lists and
4221 location lists. It will normally be specified by DW_AT_low_pc.
4222 In DWARF-3 draft 4, the base address could be overridden by
4223 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4224 compilation units with discontinuous ranges. */
4227 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
4229 struct attribute
*attr
;
4232 cu
->base_address
= 0;
4234 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
4237 cu
->base_address
= attr_value_as_address (attr
);
4242 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4245 cu
->base_address
= attr_value_as_address (attr
);
4251 /* Read in the comp unit header information from the debug_info at info_ptr.
4252 NOTE: This leaves members offset, first_die_offset to be filled in
4255 static const gdb_byte
*
4256 read_comp_unit_head (struct comp_unit_head
*cu_header
,
4257 const gdb_byte
*info_ptr
, bfd
*abfd
)
4260 unsigned int bytes_read
;
4262 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
4263 cu_header
->initial_length_size
= bytes_read
;
4264 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
4265 info_ptr
+= bytes_read
;
4266 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
4268 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
4270 info_ptr
+= bytes_read
;
4271 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
4273 signed_addr
= bfd_get_sign_extend_vma (abfd
);
4274 if (signed_addr
< 0)
4275 internal_error (__FILE__
, __LINE__
,
4276 _("read_comp_unit_head: dwarf from non elf file"));
4277 cu_header
->signed_addr_p
= signed_addr
;
4282 /* Helper function that returns the proper abbrev section for
4285 static struct dwarf2_section_info
*
4286 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
4288 struct dwarf2_section_info
*abbrev
;
4290 if (this_cu
->is_dwz
)
4291 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
4293 abbrev
= &dwarf2_per_objfile
->abbrev
;
4298 /* Subroutine of read_and_check_comp_unit_head and
4299 read_and_check_type_unit_head to simplify them.
4300 Perform various error checking on the header. */
4303 error_check_comp_unit_head (struct comp_unit_head
*header
,
4304 struct dwarf2_section_info
*section
,
4305 struct dwarf2_section_info
*abbrev_section
)
4307 bfd
*abfd
= get_section_bfd_owner (section
);
4308 const char *filename
= get_section_file_name (section
);
4310 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
4311 error (_("Dwarf Error: wrong version in compilation unit header "
4312 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
4315 if (header
->abbrev_offset
.sect_off
4316 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
4317 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4318 "(offset 0x%lx + 6) [in module %s]"),
4319 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
4322 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4323 avoid potential 32-bit overflow. */
4324 if (((unsigned long) header
->offset
.sect_off
+ get_cu_length (header
))
4326 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4327 "(offset 0x%lx + 0) [in module %s]"),
4328 (long) header
->length
, (long) header
->offset
.sect_off
,
4332 /* Read in a CU/TU header and perform some basic error checking.
4333 The contents of the header are stored in HEADER.
4334 The result is a pointer to the start of the first DIE. */
4336 static const gdb_byte
*
4337 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
4338 struct dwarf2_section_info
*section
,
4339 struct dwarf2_section_info
*abbrev_section
,
4340 const gdb_byte
*info_ptr
,
4341 int is_debug_types_section
)
4343 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4344 bfd
*abfd
= get_section_bfd_owner (section
);
4346 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4348 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4350 /* If we're reading a type unit, skip over the signature and
4351 type_offset fields. */
4352 if (is_debug_types_section
)
4353 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
4355 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4357 error_check_comp_unit_head (header
, section
, abbrev_section
);
4362 /* Read in the types comp unit header information from .debug_types entry at
4363 types_ptr. The result is a pointer to one past the end of the header. */
4365 static const gdb_byte
*
4366 read_and_check_type_unit_head (struct comp_unit_head
*header
,
4367 struct dwarf2_section_info
*section
,
4368 struct dwarf2_section_info
*abbrev_section
,
4369 const gdb_byte
*info_ptr
,
4370 ULONGEST
*signature
,
4371 cu_offset
*type_offset_in_tu
)
4373 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4374 bfd
*abfd
= get_section_bfd_owner (section
);
4376 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4378 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4380 /* If we're reading a type unit, skip over the signature and
4381 type_offset fields. */
4382 if (signature
!= NULL
)
4383 *signature
= read_8_bytes (abfd
, info_ptr
);
4385 if (type_offset_in_tu
!= NULL
)
4386 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
4387 header
->offset_size
);
4388 info_ptr
+= header
->offset_size
;
4390 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4392 error_check_comp_unit_head (header
, section
, abbrev_section
);
4397 /* Fetch the abbreviation table offset from a comp or type unit header. */
4400 read_abbrev_offset (struct dwarf2_section_info
*section
,
4403 bfd
*abfd
= get_section_bfd_owner (section
);
4404 const gdb_byte
*info_ptr
;
4405 unsigned int length
, initial_length_size
, offset_size
;
4406 sect_offset abbrev_offset
;
4408 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
4409 info_ptr
= section
->buffer
+ offset
.sect_off
;
4410 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
4411 offset_size
= initial_length_size
== 4 ? 4 : 8;
4412 info_ptr
+= initial_length_size
+ 2 /*version*/;
4413 abbrev_offset
.sect_off
= read_offset_1 (abfd
, info_ptr
, offset_size
);
4414 return abbrev_offset
;
4417 /* Allocate a new partial symtab for file named NAME and mark this new
4418 partial symtab as being an include of PST. */
4421 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
4422 struct objfile
*objfile
)
4424 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
4426 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
4428 /* It shares objfile->objfile_obstack. */
4429 subpst
->dirname
= pst
->dirname
;
4432 subpst
->section_offsets
= pst
->section_offsets
;
4433 subpst
->textlow
= 0;
4434 subpst
->texthigh
= 0;
4436 subpst
->dependencies
= (struct partial_symtab
**)
4437 obstack_alloc (&objfile
->objfile_obstack
,
4438 sizeof (struct partial_symtab
*));
4439 subpst
->dependencies
[0] = pst
;
4440 subpst
->number_of_dependencies
= 1;
4442 subpst
->globals_offset
= 0;
4443 subpst
->n_global_syms
= 0;
4444 subpst
->statics_offset
= 0;
4445 subpst
->n_static_syms
= 0;
4446 subpst
->symtab
= NULL
;
4447 subpst
->read_symtab
= pst
->read_symtab
;
4450 /* No private part is necessary for include psymtabs. This property
4451 can be used to differentiate between such include psymtabs and
4452 the regular ones. */
4453 subpst
->read_symtab_private
= NULL
;
4456 /* Read the Line Number Program data and extract the list of files
4457 included by the source file represented by PST. Build an include
4458 partial symtab for each of these included files. */
4461 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
4462 struct die_info
*die
,
4463 struct partial_symtab
*pst
)
4465 struct line_header
*lh
= NULL
;
4466 struct attribute
*attr
;
4468 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
4470 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
4472 return; /* No linetable, so no includes. */
4474 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4475 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, 1);
4477 free_line_header (lh
);
4481 hash_signatured_type (const void *item
)
4483 const struct signatured_type
*sig_type
= item
;
4485 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4486 return sig_type
->signature
;
4490 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
4492 const struct signatured_type
*lhs
= item_lhs
;
4493 const struct signatured_type
*rhs
= item_rhs
;
4495 return lhs
->signature
== rhs
->signature
;
4498 /* Allocate a hash table for signatured types. */
4501 allocate_signatured_type_table (struct objfile
*objfile
)
4503 return htab_create_alloc_ex (41,
4504 hash_signatured_type
,
4507 &objfile
->objfile_obstack
,
4508 hashtab_obstack_allocate
,
4509 dummy_obstack_deallocate
);
4512 /* A helper function to add a signatured type CU to a table. */
4515 add_signatured_type_cu_to_table (void **slot
, void *datum
)
4517 struct signatured_type
*sigt
= *slot
;
4518 struct signatured_type
***datap
= datum
;
4526 /* Create the hash table of all entries in the .debug_types
4527 (or .debug_types.dwo) section(s).
4528 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4529 otherwise it is NULL.
4531 The result is a pointer to the hash table or NULL if there are no types.
4533 Note: This function processes DWO files only, not DWP files. */
4536 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
4537 VEC (dwarf2_section_info_def
) *types
)
4539 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4540 htab_t types_htab
= NULL
;
4542 struct dwarf2_section_info
*section
;
4543 struct dwarf2_section_info
*abbrev_section
;
4545 if (VEC_empty (dwarf2_section_info_def
, types
))
4548 abbrev_section
= (dwo_file
!= NULL
4549 ? &dwo_file
->sections
.abbrev
4550 : &dwarf2_per_objfile
->abbrev
);
4552 if (dwarf2_read_debug
)
4553 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_types%s for %s:\n",
4554 dwo_file
? ".dwo" : "",
4555 get_section_file_name (abbrev_section
));
4558 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
4562 const gdb_byte
*info_ptr
, *end_ptr
;
4564 dwarf2_read_section (objfile
, section
);
4565 info_ptr
= section
->buffer
;
4567 if (info_ptr
== NULL
)
4570 /* We can't set abfd until now because the section may be empty or
4571 not present, in which case the bfd is unknown. */
4572 abfd
= get_section_bfd_owner (section
);
4574 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4575 because we don't need to read any dies: the signature is in the
4578 end_ptr
= info_ptr
+ section
->size
;
4579 while (info_ptr
< end_ptr
)
4582 cu_offset type_offset_in_tu
;
4584 struct signatured_type
*sig_type
;
4585 struct dwo_unit
*dwo_tu
;
4587 const gdb_byte
*ptr
= info_ptr
;
4588 struct comp_unit_head header
;
4589 unsigned int length
;
4591 offset
.sect_off
= ptr
- section
->buffer
;
4593 /* We need to read the type's signature in order to build the hash
4594 table, but we don't need anything else just yet. */
4596 ptr
= read_and_check_type_unit_head (&header
, section
,
4597 abbrev_section
, ptr
,
4598 &signature
, &type_offset_in_tu
);
4600 length
= get_cu_length (&header
);
4602 /* Skip dummy type units. */
4603 if (ptr
>= info_ptr
+ length
4604 || peek_abbrev_code (abfd
, ptr
) == 0)
4610 if (types_htab
== NULL
)
4613 types_htab
= allocate_dwo_unit_table (objfile
);
4615 types_htab
= allocate_signatured_type_table (objfile
);
4621 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4623 dwo_tu
->dwo_file
= dwo_file
;
4624 dwo_tu
->signature
= signature
;
4625 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
4626 dwo_tu
->section
= section
;
4627 dwo_tu
->offset
= offset
;
4628 dwo_tu
->length
= length
;
4632 /* N.B.: type_offset is not usable if this type uses a DWO file.
4633 The real type_offset is in the DWO file. */
4635 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4636 struct signatured_type
);
4637 sig_type
->signature
= signature
;
4638 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
4639 sig_type
->per_cu
.objfile
= objfile
;
4640 sig_type
->per_cu
.is_debug_types
= 1;
4641 sig_type
->per_cu
.section
= section
;
4642 sig_type
->per_cu
.offset
= offset
;
4643 sig_type
->per_cu
.length
= length
;
4646 slot
= htab_find_slot (types_htab
,
4647 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
4649 gdb_assert (slot
!= NULL
);
4652 sect_offset dup_offset
;
4656 const struct dwo_unit
*dup_tu
= *slot
;
4658 dup_offset
= dup_tu
->offset
;
4662 const struct signatured_type
*dup_tu
= *slot
;
4664 dup_offset
= dup_tu
->per_cu
.offset
;
4667 complaint (&symfile_complaints
,
4668 _("debug type entry at offset 0x%x is duplicate to"
4669 " the entry at offset 0x%x, signature %s"),
4670 offset
.sect_off
, dup_offset
.sect_off
,
4671 hex_string (signature
));
4673 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
4675 if (dwarf2_read_debug
> 1)
4676 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature %s\n",
4678 hex_string (signature
));
4687 /* Create the hash table of all entries in the .debug_types section,
4688 and initialize all_type_units.
4689 The result is zero if there is an error (e.g. missing .debug_types section),
4690 otherwise non-zero. */
4693 create_all_type_units (struct objfile
*objfile
)
4696 struct signatured_type
**iter
;
4698 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
4699 if (types_htab
== NULL
)
4701 dwarf2_per_objfile
->signatured_types
= NULL
;
4705 dwarf2_per_objfile
->signatured_types
= types_htab
;
4707 dwarf2_per_objfile
->n_type_units
= htab_elements (types_htab
);
4708 dwarf2_per_objfile
->all_type_units
4709 = xmalloc (dwarf2_per_objfile
->n_type_units
4710 * sizeof (struct signatured_type
*));
4711 iter
= &dwarf2_per_objfile
->all_type_units
[0];
4712 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
4713 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
4714 == dwarf2_per_objfile
->n_type_units
);
4719 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4720 Fill in SIG_ENTRY with DWO_ENTRY. */
4723 fill_in_sig_entry_from_dwo_entry (struct objfile
*objfile
,
4724 struct signatured_type
*sig_entry
,
4725 struct dwo_unit
*dwo_entry
)
4727 /* Make sure we're not clobbering something we don't expect to. */
4728 gdb_assert (! sig_entry
->per_cu
.queued
);
4729 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
4730 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
4731 gdb_assert (sig_entry
->per_cu
.v
.quick
->symtab
== NULL
);
4732 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
4733 gdb_assert (sig_entry
->type_offset_in_section
.sect_off
== 0);
4734 gdb_assert (sig_entry
->type_unit_group
== NULL
);
4735 gdb_assert (sig_entry
->dwo_unit
== NULL
);
4737 sig_entry
->per_cu
.section
= dwo_entry
->section
;
4738 sig_entry
->per_cu
.offset
= dwo_entry
->offset
;
4739 sig_entry
->per_cu
.length
= dwo_entry
->length
;
4740 sig_entry
->per_cu
.reading_dwo_directly
= 1;
4741 sig_entry
->per_cu
.objfile
= objfile
;
4742 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
4743 sig_entry
->dwo_unit
= dwo_entry
;
4746 /* Subroutine of lookup_signatured_type.
4747 If we haven't read the TU yet, create the signatured_type data structure
4748 for a TU to be read in directly from a DWO file, bypassing the stub.
4749 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4750 using .gdb_index, then when reading a CU we want to stay in the DWO file
4751 containing that CU. Otherwise we could end up reading several other DWO
4752 files (due to comdat folding) to process the transitive closure of all the
4753 mentioned TUs, and that can be slow. The current DWO file will have every
4754 type signature that it needs.
4755 We only do this for .gdb_index because in the psymtab case we already have
4756 to read all the DWOs to build the type unit groups. */
4758 static struct signatured_type
*
4759 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4761 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4762 struct dwo_file
*dwo_file
;
4763 struct dwo_unit find_dwo_entry
, *dwo_entry
;
4764 struct signatured_type find_sig_entry
, *sig_entry
;
4766 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4768 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4769 dwo_unit of the TU itself. */
4770 dwo_file
= cu
->dwo_unit
->dwo_file
;
4772 /* We only ever need to read in one copy of a signatured type.
4773 Just use the global signatured_types array. If this is the first time
4774 we're reading this type, replace the recorded data from .gdb_index with
4777 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4779 find_sig_entry
.signature
= sig
;
4780 sig_entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_sig_entry
);
4781 if (sig_entry
== NULL
)
4784 /* We can get here with the TU already read, *or* in the process of being
4785 read. Don't reassign it if that's the case. Also note that if the TU is
4786 already being read, it may not have come from a DWO, the program may be
4787 a mix of Fission-compiled code and non-Fission-compiled code. */
4788 /* Have we already tried to read this TU? */
4789 if (sig_entry
->per_cu
.tu_read
)
4792 /* Ok, this is the first time we're reading this TU. */
4793 if (dwo_file
->tus
== NULL
)
4795 find_dwo_entry
.signature
= sig
;
4796 dwo_entry
= htab_find (dwo_file
->tus
, &find_dwo_entry
);
4797 if (dwo_entry
== NULL
)
4800 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4801 sig_entry
->per_cu
.tu_read
= 1;
4805 /* Subroutine of lookup_dwp_signatured_type.
4806 Add an entry for signature SIG to dwarf2_per_objfile->signatured_types. */
4808 static struct signatured_type
*
4809 add_type_unit (ULONGEST sig
)
4811 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4812 int n_type_units
= dwarf2_per_objfile
->n_type_units
;
4813 struct signatured_type
*sig_type
;
4817 dwarf2_per_objfile
->all_type_units
=
4818 xrealloc (dwarf2_per_objfile
->all_type_units
,
4819 n_type_units
* sizeof (struct signatured_type
*));
4820 dwarf2_per_objfile
->n_type_units
= n_type_units
;
4821 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4822 struct signatured_type
);
4823 dwarf2_per_objfile
->all_type_units
[n_type_units
- 1] = sig_type
;
4824 sig_type
->signature
= sig
;
4825 sig_type
->per_cu
.is_debug_types
= 1;
4826 sig_type
->per_cu
.v
.quick
=
4827 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4828 struct dwarf2_per_cu_quick_data
);
4829 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4831 gdb_assert (*slot
== NULL
);
4833 /* The rest of sig_type must be filled in by the caller. */
4837 /* Subroutine of lookup_signatured_type.
4838 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4839 then try the DWP file.
4840 Normally this "can't happen", but if there's a bug in signature
4841 generation and/or the DWP file is built incorrectly, it can happen.
4842 Using the type directly from the DWP file means we don't have the stub
4843 which has some useful attributes (e.g., DW_AT_comp_dir), but they're
4844 not critical. [Eventually the stub may go away for type units anyway.] */
4846 static struct signatured_type
*
4847 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4849 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4850 struct dwp_file
*dwp_file
= get_dwp_file ();
4851 struct dwo_unit
*dwo_entry
;
4852 struct signatured_type find_sig_entry
, *sig_entry
;
4854 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4855 gdb_assert (dwp_file
!= NULL
);
4857 if (dwarf2_per_objfile
->signatured_types
!= NULL
)
4859 find_sig_entry
.signature
= sig
;
4860 sig_entry
= htab_find (dwarf2_per_objfile
->signatured_types
,
4862 if (sig_entry
!= NULL
)
4866 /* This is the "shouldn't happen" case.
4867 Try the DWP file and hope for the best. */
4868 if (dwp_file
->tus
== NULL
)
4870 dwo_entry
= lookup_dwo_unit_in_dwp (dwp_file
, NULL
,
4871 sig
, 1 /* is_debug_types */);
4872 if (dwo_entry
== NULL
)
4875 sig_entry
= add_type_unit (sig
);
4876 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4878 /* The caller will signal a complaint if we return NULL.
4879 Here we don't return NULL but we still want to complain. */
4880 complaint (&symfile_complaints
,
4881 _("Bad type signature %s referenced by %s at 0x%x,"
4882 " coping by using copy in DWP [in module %s]"),
4884 cu
->per_cu
->is_debug_types
? "TU" : "CU",
4885 cu
->per_cu
->offset
.sect_off
,
4886 objfile_name (objfile
));
4891 /* Lookup a signature based type for DW_FORM_ref_sig8.
4892 Returns NULL if signature SIG is not present in the table.
4893 It is up to the caller to complain about this. */
4895 static struct signatured_type
*
4896 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4899 && dwarf2_per_objfile
->using_index
)
4901 /* We're in a DWO/DWP file, and we're using .gdb_index.
4902 These cases require special processing. */
4903 if (get_dwp_file () == NULL
)
4904 return lookup_dwo_signatured_type (cu
, sig
);
4906 return lookup_dwp_signatured_type (cu
, sig
);
4910 struct signatured_type find_entry
, *entry
;
4912 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4914 find_entry
.signature
= sig
;
4915 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
4920 /* Low level DIE reading support. */
4922 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
4925 init_cu_die_reader (struct die_reader_specs
*reader
,
4926 struct dwarf2_cu
*cu
,
4927 struct dwarf2_section_info
*section
,
4928 struct dwo_file
*dwo_file
)
4930 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
4931 reader
->abfd
= get_section_bfd_owner (section
);
4933 reader
->dwo_file
= dwo_file
;
4934 reader
->die_section
= section
;
4935 reader
->buffer
= section
->buffer
;
4936 reader
->buffer_end
= section
->buffer
+ section
->size
;
4937 reader
->comp_dir
= NULL
;
4940 /* Subroutine of init_cutu_and_read_dies to simplify it.
4941 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
4942 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
4945 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
4946 from it to the DIE in the DWO. If NULL we are skipping the stub.
4947 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
4948 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
4949 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
4950 STUB_COMP_DIR may be non-NULL.
4951 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
4952 are filled in with the info of the DIE from the DWO file.
4953 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
4954 provided an abbrev table to use.
4955 The result is non-zero if a valid (non-dummy) DIE was found. */
4958 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
4959 struct dwo_unit
*dwo_unit
,
4960 int abbrev_table_provided
,
4961 struct die_info
*stub_comp_unit_die
,
4962 const char *stub_comp_dir
,
4963 struct die_reader_specs
*result_reader
,
4964 const gdb_byte
**result_info_ptr
,
4965 struct die_info
**result_comp_unit_die
,
4966 int *result_has_children
)
4968 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4969 struct dwarf2_cu
*cu
= this_cu
->cu
;
4970 struct dwarf2_section_info
*section
;
4972 const gdb_byte
*begin_info_ptr
, *info_ptr
;
4973 ULONGEST signature
; /* Or dwo_id. */
4974 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
4975 int i
,num_extra_attrs
;
4976 struct dwarf2_section_info
*dwo_abbrev_section
;
4977 struct attribute
*attr
;
4978 struct die_info
*comp_unit_die
;
4980 /* At most one of these may be provided. */
4981 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
4983 /* These attributes aren't processed until later:
4984 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4985 DW_AT_comp_dir is used now, to find the DWO file, but it is also
4986 referenced later. However, these attributes are found in the stub
4987 which we won't have later. In order to not impose this complication
4988 on the rest of the code, we read them here and copy them to the
4997 if (stub_comp_unit_die
!= NULL
)
4999 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5001 if (! this_cu
->is_debug_types
)
5002 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
5003 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
5004 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
5005 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
5006 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
5008 /* There should be a DW_AT_addr_base attribute here (if needed).
5009 We need the value before we can process DW_FORM_GNU_addr_index. */
5011 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
5013 cu
->addr_base
= DW_UNSND (attr
);
5015 /* There should be a DW_AT_ranges_base attribute here (if needed).
5016 We need the value before we can process DW_AT_ranges. */
5017 cu
->ranges_base
= 0;
5018 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
5020 cu
->ranges_base
= DW_UNSND (attr
);
5022 else if (stub_comp_dir
!= NULL
)
5024 /* Reconstruct the comp_dir attribute to simplify the code below. */
5025 comp_dir
= (struct attribute
*)
5026 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (*comp_dir
));
5027 comp_dir
->name
= DW_AT_comp_dir
;
5028 comp_dir
->form
= DW_FORM_string
;
5029 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
5030 DW_STRING (comp_dir
) = stub_comp_dir
;
5033 /* Set up for reading the DWO CU/TU. */
5034 cu
->dwo_unit
= dwo_unit
;
5035 section
= dwo_unit
->section
;
5036 dwarf2_read_section (objfile
, section
);
5037 abfd
= get_section_bfd_owner (section
);
5038 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
5039 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
5040 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
5042 if (this_cu
->is_debug_types
)
5044 ULONGEST header_signature
;
5045 cu_offset type_offset_in_tu
;
5046 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
5048 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5052 &type_offset_in_tu
);
5053 /* This is not an assert because it can be caused by bad debug info. */
5054 if (sig_type
->signature
!= header_signature
)
5056 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5057 " TU at offset 0x%x [in module %s]"),
5058 hex_string (sig_type
->signature
),
5059 hex_string (header_signature
),
5060 dwo_unit
->offset
.sect_off
,
5061 bfd_get_filename (abfd
));
5063 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5064 /* For DWOs coming from DWP files, we don't know the CU length
5065 nor the type's offset in the TU until now. */
5066 dwo_unit
->length
= get_cu_length (&cu
->header
);
5067 dwo_unit
->type_offset_in_tu
= type_offset_in_tu
;
5069 /* Establish the type offset that can be used to lookup the type.
5070 For DWO files, we don't know it until now. */
5071 sig_type
->type_offset_in_section
.sect_off
=
5072 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
5076 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5079 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5080 /* For DWOs coming from DWP files, we don't know the CU length
5082 dwo_unit
->length
= get_cu_length (&cu
->header
);
5085 /* Replace the CU's original abbrev table with the DWO's.
5086 Reminder: We can't read the abbrev table until we've read the header. */
5087 if (abbrev_table_provided
)
5089 /* Don't free the provided abbrev table, the caller of
5090 init_cutu_and_read_dies owns it. */
5091 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5092 /* Ensure the DWO abbrev table gets freed. */
5093 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5097 dwarf2_free_abbrev_table (cu
);
5098 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5099 /* Leave any existing abbrev table cleanup as is. */
5102 /* Read in the die, but leave space to copy over the attributes
5103 from the stub. This has the benefit of simplifying the rest of
5104 the code - all the work to maintain the illusion of a single
5105 DW_TAG_{compile,type}_unit DIE is done here. */
5106 num_extra_attrs
= ((stmt_list
!= NULL
)
5110 + (comp_dir
!= NULL
));
5111 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
5112 result_has_children
, num_extra_attrs
);
5114 /* Copy over the attributes from the stub to the DIE we just read in. */
5115 comp_unit_die
= *result_comp_unit_die
;
5116 i
= comp_unit_die
->num_attrs
;
5117 if (stmt_list
!= NULL
)
5118 comp_unit_die
->attrs
[i
++] = *stmt_list
;
5120 comp_unit_die
->attrs
[i
++] = *low_pc
;
5121 if (high_pc
!= NULL
)
5122 comp_unit_die
->attrs
[i
++] = *high_pc
;
5124 comp_unit_die
->attrs
[i
++] = *ranges
;
5125 if (comp_dir
!= NULL
)
5126 comp_unit_die
->attrs
[i
++] = *comp_dir
;
5127 comp_unit_die
->num_attrs
+= num_extra_attrs
;
5129 if (dwarf2_die_debug
)
5131 fprintf_unfiltered (gdb_stdlog
,
5132 "Read die from %s@0x%x of %s:\n",
5133 get_section_name (section
),
5134 (unsigned) (begin_info_ptr
- section
->buffer
),
5135 bfd_get_filename (abfd
));
5136 dump_die (comp_unit_die
, dwarf2_die_debug
);
5139 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5140 TUs by skipping the stub and going directly to the entry in the DWO file.
5141 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5142 to get it via circuitous means. Blech. */
5143 if (comp_dir
!= NULL
)
5144 result_reader
->comp_dir
= DW_STRING (comp_dir
);
5146 /* Skip dummy compilation units. */
5147 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
5148 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5151 *result_info_ptr
= info_ptr
;
5155 /* Subroutine of init_cutu_and_read_dies to simplify it.
5156 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5157 Returns NULL if the specified DWO unit cannot be found. */
5159 static struct dwo_unit
*
5160 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
5161 struct die_info
*comp_unit_die
)
5163 struct dwarf2_cu
*cu
= this_cu
->cu
;
5164 struct attribute
*attr
;
5166 struct dwo_unit
*dwo_unit
;
5167 const char *comp_dir
, *dwo_name
;
5169 gdb_assert (cu
!= NULL
);
5171 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5172 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5173 gdb_assert (attr
!= NULL
);
5174 dwo_name
= DW_STRING (attr
);
5176 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5178 comp_dir
= DW_STRING (attr
);
5180 if (this_cu
->is_debug_types
)
5182 struct signatured_type
*sig_type
;
5184 /* Since this_cu is the first member of struct signatured_type,
5185 we can go from a pointer to one to a pointer to the other. */
5186 sig_type
= (struct signatured_type
*) this_cu
;
5187 signature
= sig_type
->signature
;
5188 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
5192 struct attribute
*attr
;
5194 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
5196 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5198 dwo_name
, objfile_name (this_cu
->objfile
));
5199 signature
= DW_UNSND (attr
);
5200 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
5207 /* Subroutine of init_cutu_and_read_dies to simplify it.
5208 Read a TU directly from a DWO file, bypassing the stub. */
5211 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
, int keep
,
5212 die_reader_func_ftype
*die_reader_func
,
5215 struct dwarf2_cu
*cu
;
5216 struct signatured_type
*sig_type
;
5217 struct cleanup
*cleanups
, *free_cu_cleanup
;
5218 struct die_reader_specs reader
;
5219 const gdb_byte
*info_ptr
;
5220 struct die_info
*comp_unit_die
;
5223 /* Verify we can do the following downcast, and that we have the
5225 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
5226 sig_type
= (struct signatured_type
*) this_cu
;
5227 gdb_assert (sig_type
->dwo_unit
!= NULL
);
5229 cleanups
= make_cleanup (null_cleanup
, NULL
);
5231 gdb_assert (this_cu
->cu
== NULL
);
5232 cu
= xmalloc (sizeof (*cu
));
5233 init_one_comp_unit (cu
, this_cu
);
5234 /* If an error occurs while loading, release our storage. */
5235 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5237 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
5238 0 /* abbrev_table_provided */,
5239 NULL
/* stub_comp_unit_die */,
5240 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
5242 &comp_unit_die
, &has_children
) == 0)
5245 do_cleanups (cleanups
);
5249 /* All the "real" work is done here. */
5250 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5252 /* This duplicates some code in init_cutu_and_read_dies,
5253 but the alternative is making the latter more complex.
5254 This function is only for the special case of using DWO files directly:
5255 no point in overly complicating the general case just to handle this. */
5258 /* We've successfully allocated this compilation unit. Let our
5259 caller clean it up when finished with it. */
5260 discard_cleanups (free_cu_cleanup
);
5262 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5263 So we have to manually free the abbrev table. */
5264 dwarf2_free_abbrev_table (cu
);
5266 /* Link this CU into read_in_chain. */
5267 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5268 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5271 do_cleanups (free_cu_cleanup
);
5273 do_cleanups (cleanups
);
5276 /* Initialize a CU (or TU) and read its DIEs.
5277 If the CU defers to a DWO file, read the DWO file as well.
5279 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5280 Otherwise the table specified in the comp unit header is read in and used.
5281 This is an optimization for when we already have the abbrev table.
5283 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5284 Otherwise, a new CU is allocated with xmalloc.
5286 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5287 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5289 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5290 linker) then DIE_READER_FUNC will not get called. */
5293 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
5294 struct abbrev_table
*abbrev_table
,
5295 int use_existing_cu
, int keep
,
5296 die_reader_func_ftype
*die_reader_func
,
5299 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5300 struct dwarf2_section_info
*section
= this_cu
->section
;
5301 bfd
*abfd
= get_section_bfd_owner (section
);
5302 struct dwarf2_cu
*cu
;
5303 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5304 struct die_reader_specs reader
;
5305 struct die_info
*comp_unit_die
;
5307 struct attribute
*attr
;
5308 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5309 struct signatured_type
*sig_type
= NULL
;
5310 struct dwarf2_section_info
*abbrev_section
;
5311 /* Non-zero if CU currently points to a DWO file and we need to
5312 reread it. When this happens we need to reread the skeleton die
5313 before we can reread the DWO file (this only applies to CUs, not TUs). */
5314 int rereading_dwo_cu
= 0;
5316 if (dwarf2_die_debug
)
5317 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5318 this_cu
->is_debug_types
? "type" : "comp",
5319 this_cu
->offset
.sect_off
);
5321 if (use_existing_cu
)
5324 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5325 file (instead of going through the stub), short-circuit all of this. */
5326 if (this_cu
->reading_dwo_directly
)
5328 /* Narrow down the scope of possibilities to have to understand. */
5329 gdb_assert (this_cu
->is_debug_types
);
5330 gdb_assert (abbrev_table
== NULL
);
5331 gdb_assert (!use_existing_cu
);
5332 init_tu_and_read_dwo_dies (this_cu
, keep
, die_reader_func
, data
);
5336 cleanups
= make_cleanup (null_cleanup
, NULL
);
5338 /* This is cheap if the section is already read in. */
5339 dwarf2_read_section (objfile
, section
);
5341 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5343 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
5345 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5349 /* If this CU is from a DWO file we need to start over, we need to
5350 refetch the attributes from the skeleton CU.
5351 This could be optimized by retrieving those attributes from when we
5352 were here the first time: the previous comp_unit_die was stored in
5353 comp_unit_obstack. But there's no data yet that we need this
5355 if (cu
->dwo_unit
!= NULL
)
5356 rereading_dwo_cu
= 1;
5360 /* If !use_existing_cu, this_cu->cu must be NULL. */
5361 gdb_assert (this_cu
->cu
== NULL
);
5363 cu
= xmalloc (sizeof (*cu
));
5364 init_one_comp_unit (cu
, this_cu
);
5366 /* If an error occurs while loading, release our storage. */
5367 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5370 /* Get the header. */
5371 if (cu
->header
.first_die_offset
.cu_off
!= 0 && ! rereading_dwo_cu
)
5373 /* We already have the header, there's no need to read it in again. */
5374 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
5378 if (this_cu
->is_debug_types
)
5381 cu_offset type_offset_in_tu
;
5383 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5384 abbrev_section
, info_ptr
,
5386 &type_offset_in_tu
);
5388 /* Since per_cu is the first member of struct signatured_type,
5389 we can go from a pointer to one to a pointer to the other. */
5390 sig_type
= (struct signatured_type
*) this_cu
;
5391 gdb_assert (sig_type
->signature
== signature
);
5392 gdb_assert (sig_type
->type_offset_in_tu
.cu_off
5393 == type_offset_in_tu
.cu_off
);
5394 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5396 /* LENGTH has not been set yet for type units if we're
5397 using .gdb_index. */
5398 this_cu
->length
= get_cu_length (&cu
->header
);
5400 /* Establish the type offset that can be used to lookup the type. */
5401 sig_type
->type_offset_in_section
.sect_off
=
5402 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
5406 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5410 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5411 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
5415 /* Skip dummy compilation units. */
5416 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5417 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5419 do_cleanups (cleanups
);
5423 /* If we don't have them yet, read the abbrevs for this compilation unit.
5424 And if we need to read them now, make sure they're freed when we're
5425 done. Note that it's important that if the CU had an abbrev table
5426 on entry we don't free it when we're done: Somewhere up the call stack
5427 it may be in use. */
5428 if (abbrev_table
!= NULL
)
5430 gdb_assert (cu
->abbrev_table
== NULL
);
5431 gdb_assert (cu
->header
.abbrev_offset
.sect_off
5432 == abbrev_table
->offset
.sect_off
);
5433 cu
->abbrev_table
= abbrev_table
;
5435 else if (cu
->abbrev_table
== NULL
)
5437 dwarf2_read_abbrevs (cu
, abbrev_section
);
5438 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5440 else if (rereading_dwo_cu
)
5442 dwarf2_free_abbrev_table (cu
);
5443 dwarf2_read_abbrevs (cu
, abbrev_section
);
5446 /* Read the top level CU/TU die. */
5447 init_cu_die_reader (&reader
, cu
, section
, NULL
);
5448 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5450 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5452 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5453 DWO CU, that this test will fail (the attribute will not be present). */
5454 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5457 struct dwo_unit
*dwo_unit
;
5458 struct die_info
*dwo_comp_unit_die
;
5462 complaint (&symfile_complaints
,
5463 _("compilation unit with DW_AT_GNU_dwo_name"
5464 " has children (offset 0x%x) [in module %s]"),
5465 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
5467 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
5468 if (dwo_unit
!= NULL
)
5470 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
5471 abbrev_table
!= NULL
,
5472 comp_unit_die
, NULL
,
5474 &dwo_comp_unit_die
, &has_children
) == 0)
5477 do_cleanups (cleanups
);
5480 comp_unit_die
= dwo_comp_unit_die
;
5484 /* Yikes, we couldn't find the rest of the DIE, we only have
5485 the stub. A complaint has already been logged. There's
5486 not much more we can do except pass on the stub DIE to
5487 die_reader_func. We don't want to throw an error on bad
5492 /* All of the above is setup for this call. Yikes. */
5493 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5495 /* Done, clean up. */
5496 if (free_cu_cleanup
!= NULL
)
5500 /* We've successfully allocated this compilation unit. Let our
5501 caller clean it up when finished with it. */
5502 discard_cleanups (free_cu_cleanup
);
5504 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5505 So we have to manually free the abbrev table. */
5506 dwarf2_free_abbrev_table (cu
);
5508 /* Link this CU into read_in_chain. */
5509 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5510 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5513 do_cleanups (free_cu_cleanup
);
5516 do_cleanups (cleanups
);
5519 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5520 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5521 to have already done the lookup to find the DWO file).
5523 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5524 THIS_CU->is_debug_types, but nothing else.
5526 We fill in THIS_CU->length.
5528 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5529 linker) then DIE_READER_FUNC will not get called.
5531 THIS_CU->cu is always freed when done.
5532 This is done in order to not leave THIS_CU->cu in a state where we have
5533 to care whether it refers to the "main" CU or the DWO CU. */
5536 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
5537 struct dwo_file
*dwo_file
,
5538 die_reader_func_ftype
*die_reader_func
,
5541 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5542 struct dwarf2_section_info
*section
= this_cu
->section
;
5543 bfd
*abfd
= get_section_bfd_owner (section
);
5544 struct dwarf2_section_info
*abbrev_section
;
5545 struct dwarf2_cu cu
;
5546 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5547 struct die_reader_specs reader
;
5548 struct cleanup
*cleanups
;
5549 struct die_info
*comp_unit_die
;
5552 if (dwarf2_die_debug
)
5553 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5554 this_cu
->is_debug_types
? "type" : "comp",
5555 this_cu
->offset
.sect_off
);
5557 gdb_assert (this_cu
->cu
== NULL
);
5559 abbrev_section
= (dwo_file
!= NULL
5560 ? &dwo_file
->sections
.abbrev
5561 : get_abbrev_section_for_cu (this_cu
));
5563 /* This is cheap if the section is already read in. */
5564 dwarf2_read_section (objfile
, section
);
5566 init_one_comp_unit (&cu
, this_cu
);
5568 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
5570 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5571 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
5572 abbrev_section
, info_ptr
,
5573 this_cu
->is_debug_types
);
5575 this_cu
->length
= get_cu_length (&cu
.header
);
5577 /* Skip dummy compilation units. */
5578 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5579 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5581 do_cleanups (cleanups
);
5585 dwarf2_read_abbrevs (&cu
, abbrev_section
);
5586 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
5588 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
5589 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5591 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5593 do_cleanups (cleanups
);
5596 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5597 does not lookup the specified DWO file.
5598 This cannot be used to read DWO files.
5600 THIS_CU->cu is always freed when done.
5601 This is done in order to not leave THIS_CU->cu in a state where we have
5602 to care whether it refers to the "main" CU or the DWO CU.
5603 We can revisit this if the data shows there's a performance issue. */
5606 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
5607 die_reader_func_ftype
*die_reader_func
,
5610 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
5613 /* Type Unit Groups.
5615 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5616 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5617 so that all types coming from the same compilation (.o file) are grouped
5618 together. A future step could be to put the types in the same symtab as
5619 the CU the types ultimately came from. */
5622 hash_type_unit_group (const void *item
)
5624 const struct type_unit_group
*tu_group
= item
;
5626 return hash_stmt_list_entry (&tu_group
->hash
);
5630 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
5632 const struct type_unit_group
*lhs
= item_lhs
;
5633 const struct type_unit_group
*rhs
= item_rhs
;
5635 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
5638 /* Allocate a hash table for type unit groups. */
5641 allocate_type_unit_groups_table (void)
5643 return htab_create_alloc_ex (3,
5644 hash_type_unit_group
,
5647 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
5648 hashtab_obstack_allocate
,
5649 dummy_obstack_deallocate
);
5652 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5653 partial symtabs. We combine several TUs per psymtab to not let the size
5654 of any one psymtab grow too big. */
5655 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5656 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5658 /* Helper routine for get_type_unit_group.
5659 Create the type_unit_group object used to hold one or more TUs. */
5661 static struct type_unit_group
*
5662 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
5664 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5665 struct dwarf2_per_cu_data
*per_cu
;
5666 struct type_unit_group
*tu_group
;
5668 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5669 struct type_unit_group
);
5670 per_cu
= &tu_group
->per_cu
;
5671 per_cu
->objfile
= objfile
;
5673 if (dwarf2_per_objfile
->using_index
)
5675 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5676 struct dwarf2_per_cu_quick_data
);
5680 unsigned int line_offset
= line_offset_struct
.sect_off
;
5681 struct partial_symtab
*pst
;
5684 /* Give the symtab a useful name for debug purposes. */
5685 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
5686 name
= xstrprintf ("<type_units_%d>",
5687 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
5689 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
5691 pst
= create_partial_symtab (per_cu
, name
);
5697 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
5698 tu_group
->hash
.line_offset
= line_offset_struct
;
5703 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5704 STMT_LIST is a DW_AT_stmt_list attribute. */
5706 static struct type_unit_group
*
5707 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
5709 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5710 struct type_unit_group
*tu_group
;
5712 unsigned int line_offset
;
5713 struct type_unit_group type_unit_group_for_lookup
;
5715 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
5717 dwarf2_per_objfile
->type_unit_groups
=
5718 allocate_type_unit_groups_table ();
5721 /* Do we need to create a new group, or can we use an existing one? */
5725 line_offset
= DW_UNSND (stmt_list
);
5726 ++tu_stats
->nr_symtab_sharers
;
5730 /* Ugh, no stmt_list. Rare, but we have to handle it.
5731 We can do various things here like create one group per TU or
5732 spread them over multiple groups to split up the expansion work.
5733 To avoid worst case scenarios (too many groups or too large groups)
5734 we, umm, group them in bunches. */
5735 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5736 | (tu_stats
->nr_stmt_less_type_units
5737 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
5738 ++tu_stats
->nr_stmt_less_type_units
;
5741 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
5742 type_unit_group_for_lookup
.hash
.line_offset
.sect_off
= line_offset
;
5743 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
5744 &type_unit_group_for_lookup
, INSERT
);
5748 gdb_assert (tu_group
!= NULL
);
5752 sect_offset line_offset_struct
;
5754 line_offset_struct
.sect_off
= line_offset
;
5755 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
5757 ++tu_stats
->nr_symtabs
;
5763 /* Struct used to sort TUs by their abbreviation table offset. */
5765 struct tu_abbrev_offset
5767 struct signatured_type
*sig_type
;
5768 sect_offset abbrev_offset
;
5771 /* Helper routine for build_type_unit_groups, passed to qsort. */
5774 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
5776 const struct tu_abbrev_offset
* const *a
= ap
;
5777 const struct tu_abbrev_offset
* const *b
= bp
;
5778 unsigned int aoff
= (*a
)->abbrev_offset
.sect_off
;
5779 unsigned int boff
= (*b
)->abbrev_offset
.sect_off
;
5781 return (aoff
> boff
) - (aoff
< boff
);
5784 /* A helper function to add a type_unit_group to a table. */
5787 add_type_unit_group_to_table (void **slot
, void *datum
)
5789 struct type_unit_group
*tu_group
= *slot
;
5790 struct type_unit_group
***datap
= datum
;
5798 /* Efficiently read all the type units, calling init_cutu_and_read_dies on
5799 each one passing FUNC,DATA.
5801 The efficiency is because we sort TUs by the abbrev table they use and
5802 only read each abbrev table once. In one program there are 200K TUs
5803 sharing 8K abbrev tables.
5805 The main purpose of this function is to support building the
5806 dwarf2_per_objfile->type_unit_groups table.
5807 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
5808 can collapse the search space by grouping them by stmt_list.
5809 The savings can be significant, in the same program from above the 200K TUs
5810 share 8K stmt_list tables.
5812 FUNC is expected to call get_type_unit_group, which will create the
5813 struct type_unit_group if necessary and add it to
5814 dwarf2_per_objfile->type_unit_groups. */
5817 build_type_unit_groups (die_reader_func_ftype
*func
, void *data
)
5819 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5820 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5821 struct cleanup
*cleanups
;
5822 struct abbrev_table
*abbrev_table
;
5823 sect_offset abbrev_offset
;
5824 struct tu_abbrev_offset
*sorted_by_abbrev
;
5825 struct type_unit_group
**iter
;
5828 /* It's up to the caller to not call us multiple times. */
5829 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
5831 if (dwarf2_per_objfile
->n_type_units
== 0)
5834 /* TUs typically share abbrev tables, and there can be way more TUs than
5835 abbrev tables. Sort by abbrev table to reduce the number of times we
5836 read each abbrev table in.
5837 Alternatives are to punt or to maintain a cache of abbrev tables.
5838 This is simpler and efficient enough for now.
5840 Later we group TUs by their DW_AT_stmt_list value (as this defines the
5841 symtab to use). Typically TUs with the same abbrev offset have the same
5842 stmt_list value too so in practice this should work well.
5844 The basic algorithm here is:
5846 sort TUs by abbrev table
5847 for each TU with same abbrev table:
5848 read abbrev table if first user
5849 read TU top level DIE
5850 [IWBN if DWO skeletons had DW_AT_stmt_list]
5853 if (dwarf2_read_debug
)
5854 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
5856 /* Sort in a separate table to maintain the order of all_type_units
5857 for .gdb_index: TU indices directly index all_type_units. */
5858 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
5859 dwarf2_per_objfile
->n_type_units
);
5860 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
5862 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
5864 sorted_by_abbrev
[i
].sig_type
= sig_type
;
5865 sorted_by_abbrev
[i
].abbrev_offset
=
5866 read_abbrev_offset (sig_type
->per_cu
.section
,
5867 sig_type
->per_cu
.offset
);
5869 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
5870 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
5871 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
5873 /* Note: In the .gdb_index case, get_type_unit_group may have already been
5874 called any number of times, so we don't reset tu_stats here. */
5876 abbrev_offset
.sect_off
= ~(unsigned) 0;
5877 abbrev_table
= NULL
;
5878 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
5880 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
5882 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
5884 /* Switch to the next abbrev table if necessary. */
5885 if (abbrev_table
== NULL
5886 || tu
->abbrev_offset
.sect_off
!= abbrev_offset
.sect_off
)
5888 if (abbrev_table
!= NULL
)
5890 abbrev_table_free (abbrev_table
);
5891 /* Reset to NULL in case abbrev_table_read_table throws
5892 an error: abbrev_table_free_cleanup will get called. */
5893 abbrev_table
= NULL
;
5895 abbrev_offset
= tu
->abbrev_offset
;
5897 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
5899 ++tu_stats
->nr_uniq_abbrev_tables
;
5902 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
5906 /* type_unit_groups can be NULL if there is an error in the debug info.
5907 Just create an empty table so the rest of gdb doesn't have to watch
5908 for this error case. */
5909 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
5911 dwarf2_per_objfile
->type_unit_groups
=
5912 allocate_type_unit_groups_table ();
5913 dwarf2_per_objfile
->n_type_unit_groups
= 0;
5916 /* Create a vector of pointers to primary type units to make it easy to
5917 iterate over them and CUs. See dw2_get_primary_cu. */
5918 dwarf2_per_objfile
->n_type_unit_groups
=
5919 htab_elements (dwarf2_per_objfile
->type_unit_groups
);
5920 dwarf2_per_objfile
->all_type_unit_groups
=
5921 obstack_alloc (&objfile
->objfile_obstack
,
5922 dwarf2_per_objfile
->n_type_unit_groups
5923 * sizeof (struct type_unit_group
*));
5924 iter
= &dwarf2_per_objfile
->all_type_unit_groups
[0];
5925 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
5926 add_type_unit_group_to_table
, &iter
);
5927 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_unit_groups
[0]
5928 == dwarf2_per_objfile
->n_type_unit_groups
);
5930 do_cleanups (cleanups
);
5932 if (dwarf2_read_debug
)
5934 fprintf_unfiltered (gdb_stdlog
, "Done building type unit groups:\n");
5935 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
5936 dwarf2_per_objfile
->n_type_units
);
5937 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
5938 tu_stats
->nr_uniq_abbrev_tables
);
5939 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
5940 tu_stats
->nr_symtabs
);
5941 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
5942 tu_stats
->nr_symtab_sharers
);
5943 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
5944 tu_stats
->nr_stmt_less_type_units
);
5948 /* Partial symbol tables. */
5950 /* Create a psymtab named NAME and assign it to PER_CU.
5952 The caller must fill in the following details:
5953 dirname, textlow, texthigh. */
5955 static struct partial_symtab
*
5956 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
5958 struct objfile
*objfile
= per_cu
->objfile
;
5959 struct partial_symtab
*pst
;
5961 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
5963 objfile
->global_psymbols
.next
,
5964 objfile
->static_psymbols
.next
);
5966 pst
->psymtabs_addrmap_supported
= 1;
5968 /* This is the glue that links PST into GDB's symbol API. */
5969 pst
->read_symtab_private
= per_cu
;
5970 pst
->read_symtab
= dwarf2_read_symtab
;
5971 per_cu
->v
.psymtab
= pst
;
5976 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5979 struct process_psymtab_comp_unit_data
5981 /* True if we are reading a DW_TAG_partial_unit. */
5983 int want_partial_unit
;
5985 /* The "pretend" language that is used if the CU doesn't declare a
5988 enum language pretend_language
;
5991 /* die_reader_func for process_psymtab_comp_unit. */
5994 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
5995 const gdb_byte
*info_ptr
,
5996 struct die_info
*comp_unit_die
,
6000 struct dwarf2_cu
*cu
= reader
->cu
;
6001 struct objfile
*objfile
= cu
->objfile
;
6002 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6003 struct attribute
*attr
;
6005 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
6006 struct partial_symtab
*pst
;
6008 const char *filename
;
6009 struct process_psymtab_comp_unit_data
*info
= data
;
6011 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
6014 gdb_assert (! per_cu
->is_debug_types
);
6016 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
6018 cu
->list_in_scope
= &file_symbols
;
6020 /* Allocate a new partial symbol table structure. */
6021 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
6022 if (attr
== NULL
|| !DW_STRING (attr
))
6025 filename
= DW_STRING (attr
);
6027 pst
= create_partial_symtab (per_cu
, filename
);
6029 /* This must be done before calling dwarf2_build_include_psymtabs. */
6030 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
6032 pst
->dirname
= DW_STRING (attr
);
6034 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6036 dwarf2_find_base_address (comp_unit_die
, cu
);
6038 /* Possibly set the default values of LOWPC and HIGHPC from
6040 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
6041 &best_highpc
, cu
, pst
);
6042 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
6043 /* Store the contiguous range if it is not empty; it can be empty for
6044 CUs with no code. */
6045 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6046 best_lowpc
+ baseaddr
,
6047 best_highpc
+ baseaddr
- 1, pst
);
6049 /* Check if comp unit has_children.
6050 If so, read the rest of the partial symbols from this comp unit.
6051 If not, there's no more debug_info for this comp unit. */
6054 struct partial_die_info
*first_die
;
6055 CORE_ADDR lowpc
, highpc
;
6057 lowpc
= ((CORE_ADDR
) -1);
6058 highpc
= ((CORE_ADDR
) 0);
6060 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6062 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
6065 /* If we didn't find a lowpc, set it to highpc to avoid
6066 complaints from `maint check'. */
6067 if (lowpc
== ((CORE_ADDR
) -1))
6070 /* If the compilation unit didn't have an explicit address range,
6071 then use the information extracted from its child dies. */
6075 best_highpc
= highpc
;
6078 pst
->textlow
= best_lowpc
+ baseaddr
;
6079 pst
->texthigh
= best_highpc
+ baseaddr
;
6081 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6082 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6083 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6084 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6085 sort_pst_symbols (objfile
, pst
);
6087 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
6090 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6091 struct dwarf2_per_cu_data
*iter
;
6093 /* Fill in 'dependencies' here; we fill in 'users' in a
6095 pst
->number_of_dependencies
= len
;
6096 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6097 len
* sizeof (struct symtab
*));
6099 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
6102 pst
->dependencies
[i
] = iter
->v
.psymtab
;
6104 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6107 /* Get the list of files included in the current compilation unit,
6108 and build a psymtab for each of them. */
6109 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
6111 if (dwarf2_read_debug
)
6113 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6115 fprintf_unfiltered (gdb_stdlog
,
6116 "Psymtab for %s unit @0x%x: %s - %s"
6117 ", %d global, %d static syms\n",
6118 per_cu
->is_debug_types
? "type" : "comp",
6119 per_cu
->offset
.sect_off
,
6120 paddress (gdbarch
, pst
->textlow
),
6121 paddress (gdbarch
, pst
->texthigh
),
6122 pst
->n_global_syms
, pst
->n_static_syms
);
6126 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6127 Process compilation unit THIS_CU for a psymtab. */
6130 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
6131 int want_partial_unit
,
6132 enum language pretend_language
)
6134 struct process_psymtab_comp_unit_data info
;
6136 /* If this compilation unit was already read in, free the
6137 cached copy in order to read it in again. This is
6138 necessary because we skipped some symbols when we first
6139 read in the compilation unit (see load_partial_dies).
6140 This problem could be avoided, but the benefit is unclear. */
6141 if (this_cu
->cu
!= NULL
)
6142 free_one_cached_comp_unit (this_cu
);
6144 gdb_assert (! this_cu
->is_debug_types
);
6145 info
.want_partial_unit
= want_partial_unit
;
6146 info
.pretend_language
= pretend_language
;
6147 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
6148 process_psymtab_comp_unit_reader
,
6151 /* Age out any secondary CUs. */
6152 age_cached_comp_units ();
6155 /* Reader function for build_type_psymtabs. */
6158 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
6159 const gdb_byte
*info_ptr
,
6160 struct die_info
*type_unit_die
,
6164 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6165 struct dwarf2_cu
*cu
= reader
->cu
;
6166 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6167 struct signatured_type
*sig_type
;
6168 struct type_unit_group
*tu_group
;
6169 struct attribute
*attr
;
6170 struct partial_die_info
*first_die
;
6171 CORE_ADDR lowpc
, highpc
;
6172 struct partial_symtab
*pst
;
6174 gdb_assert (data
== NULL
);
6175 gdb_assert (per_cu
->is_debug_types
);
6176 sig_type
= (struct signatured_type
*) per_cu
;
6181 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
6182 tu_group
= get_type_unit_group (cu
, attr
);
6184 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
6186 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
6187 cu
->list_in_scope
= &file_symbols
;
6188 pst
= create_partial_symtab (per_cu
, "");
6191 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6193 lowpc
= (CORE_ADDR
) -1;
6194 highpc
= (CORE_ADDR
) 0;
6195 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
6197 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6198 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6199 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6200 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6201 sort_pst_symbols (objfile
, pst
);
6204 /* Traversal function for build_type_psymtabs. */
6207 build_type_psymtab_dependencies (void **slot
, void *info
)
6209 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6210 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
6211 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
6212 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6213 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
6214 struct signatured_type
*iter
;
6217 gdb_assert (len
> 0);
6218 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
6220 pst
->number_of_dependencies
= len
;
6221 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6222 len
* sizeof (struct psymtab
*));
6224 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
6227 gdb_assert (iter
->per_cu
.is_debug_types
);
6228 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
6229 iter
->type_unit_group
= tu_group
;
6232 VEC_free (sig_type_ptr
, tu_group
->tus
);
6237 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6238 Build partial symbol tables for the .debug_types comp-units. */
6241 build_type_psymtabs (struct objfile
*objfile
)
6243 if (! create_all_type_units (objfile
))
6246 build_type_unit_groups (build_type_psymtabs_reader
, NULL
);
6248 /* Now that all TUs have been processed we can fill in the dependencies. */
6249 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
6250 build_type_psymtab_dependencies
, NULL
);
6253 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6256 psymtabs_addrmap_cleanup (void *o
)
6258 struct objfile
*objfile
= o
;
6260 objfile
->psymtabs_addrmap
= NULL
;
6263 /* Compute the 'user' field for each psymtab in OBJFILE. */
6266 set_partial_user (struct objfile
*objfile
)
6270 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6272 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
6273 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6279 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
6281 /* Set the 'user' field only if it is not already set. */
6282 if (pst
->dependencies
[j
]->user
== NULL
)
6283 pst
->dependencies
[j
]->user
= pst
;
6288 /* Build the partial symbol table by doing a quick pass through the
6289 .debug_info and .debug_abbrev sections. */
6292 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
6294 struct cleanup
*back_to
, *addrmap_cleanup
;
6295 struct obstack temp_obstack
;
6298 if (dwarf2_read_debug
)
6300 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
6301 objfile_name (objfile
));
6304 dwarf2_per_objfile
->reading_partial_symbols
= 1;
6306 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
6308 /* Any cached compilation units will be linked by the per-objfile
6309 read_in_chain. Make sure to free them when we're done. */
6310 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
6312 build_type_psymtabs (objfile
);
6314 create_all_comp_units (objfile
);
6316 /* Create a temporary address map on a temporary obstack. We later
6317 copy this to the final obstack. */
6318 obstack_init (&temp_obstack
);
6319 make_cleanup_obstack_free (&temp_obstack
);
6320 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
6321 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
6323 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6325 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
6327 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
6330 set_partial_user (objfile
);
6332 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
6333 &objfile
->objfile_obstack
);
6334 discard_cleanups (addrmap_cleanup
);
6336 do_cleanups (back_to
);
6338 if (dwarf2_read_debug
)
6339 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
6340 objfile_name (objfile
));
6343 /* die_reader_func for load_partial_comp_unit. */
6346 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
6347 const gdb_byte
*info_ptr
,
6348 struct die_info
*comp_unit_die
,
6352 struct dwarf2_cu
*cu
= reader
->cu
;
6354 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
6356 /* Check if comp unit has_children.
6357 If so, read the rest of the partial symbols from this comp unit.
6358 If not, there's no more debug_info for this comp unit. */
6360 load_partial_dies (reader
, info_ptr
, 0);
6363 /* Load the partial DIEs for a secondary CU into memory.
6364 This is also used when rereading a primary CU with load_all_dies. */
6367 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
6369 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
6370 load_partial_comp_unit_reader
, NULL
);
6374 read_comp_units_from_section (struct objfile
*objfile
,
6375 struct dwarf2_section_info
*section
,
6376 unsigned int is_dwz
,
6379 struct dwarf2_per_cu_data
***all_comp_units
)
6381 const gdb_byte
*info_ptr
;
6382 bfd
*abfd
= get_section_bfd_owner (section
);
6384 if (dwarf2_read_debug
)
6385 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
6386 get_section_name (section
),
6387 get_section_file_name (section
));
6389 dwarf2_read_section (objfile
, section
);
6391 info_ptr
= section
->buffer
;
6393 while (info_ptr
< section
->buffer
+ section
->size
)
6395 unsigned int length
, initial_length_size
;
6396 struct dwarf2_per_cu_data
*this_cu
;
6399 offset
.sect_off
= info_ptr
- section
->buffer
;
6401 /* Read just enough information to find out where the next
6402 compilation unit is. */
6403 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6405 /* Save the compilation unit for later lookup. */
6406 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
6407 sizeof (struct dwarf2_per_cu_data
));
6408 memset (this_cu
, 0, sizeof (*this_cu
));
6409 this_cu
->offset
= offset
;
6410 this_cu
->length
= length
+ initial_length_size
;
6411 this_cu
->is_dwz
= is_dwz
;
6412 this_cu
->objfile
= objfile
;
6413 this_cu
->section
= section
;
6415 if (*n_comp_units
== *n_allocated
)
6418 *all_comp_units
= xrealloc (*all_comp_units
,
6420 * sizeof (struct dwarf2_per_cu_data
*));
6422 (*all_comp_units
)[*n_comp_units
] = this_cu
;
6425 info_ptr
= info_ptr
+ this_cu
->length
;
6429 /* Create a list of all compilation units in OBJFILE.
6430 This is only done for -readnow and building partial symtabs. */
6433 create_all_comp_units (struct objfile
*objfile
)
6437 struct dwarf2_per_cu_data
**all_comp_units
;
6438 struct dwz_file
*dwz
;
6442 all_comp_units
= xmalloc (n_allocated
6443 * sizeof (struct dwarf2_per_cu_data
*));
6445 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
, 0,
6446 &n_allocated
, &n_comp_units
, &all_comp_units
);
6448 dwz
= dwarf2_get_dwz_file ();
6450 read_comp_units_from_section (objfile
, &dwz
->info
, 1,
6451 &n_allocated
, &n_comp_units
,
6454 dwarf2_per_objfile
->all_comp_units
6455 = obstack_alloc (&objfile
->objfile_obstack
,
6456 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6457 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
6458 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6459 xfree (all_comp_units
);
6460 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
6463 /* Process all loaded DIEs for compilation unit CU, starting at
6464 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
6465 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6466 DW_AT_ranges). If NEED_PC is set, then this function will set
6467 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
6468 and record the covered ranges in the addrmap. */
6471 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
6472 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
6474 struct partial_die_info
*pdi
;
6476 /* Now, march along the PDI's, descending into ones which have
6477 interesting children but skipping the children of the other ones,
6478 until we reach the end of the compilation unit. */
6484 fixup_partial_die (pdi
, cu
);
6486 /* Anonymous namespaces or modules have no name but have interesting
6487 children, so we need to look at them. Ditto for anonymous
6490 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
6491 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
6492 || pdi
->tag
== DW_TAG_imported_unit
)
6496 case DW_TAG_subprogram
:
6497 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
6499 case DW_TAG_constant
:
6500 case DW_TAG_variable
:
6501 case DW_TAG_typedef
:
6502 case DW_TAG_union_type
:
6503 if (!pdi
->is_declaration
)
6505 add_partial_symbol (pdi
, cu
);
6508 case DW_TAG_class_type
:
6509 case DW_TAG_interface_type
:
6510 case DW_TAG_structure_type
:
6511 if (!pdi
->is_declaration
)
6513 add_partial_symbol (pdi
, cu
);
6516 case DW_TAG_enumeration_type
:
6517 if (!pdi
->is_declaration
)
6518 add_partial_enumeration (pdi
, cu
);
6520 case DW_TAG_base_type
:
6521 case DW_TAG_subrange_type
:
6522 /* File scope base type definitions are added to the partial
6524 add_partial_symbol (pdi
, cu
);
6526 case DW_TAG_namespace
:
6527 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
6530 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
6532 case DW_TAG_imported_unit
:
6534 struct dwarf2_per_cu_data
*per_cu
;
6536 /* For now we don't handle imported units in type units. */
6537 if (cu
->per_cu
->is_debug_types
)
6539 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6540 " supported in type units [in module %s]"),
6541 objfile_name (cu
->objfile
));
6544 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
6548 /* Go read the partial unit, if needed. */
6549 if (per_cu
->v
.psymtab
== NULL
)
6550 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
6552 VEC_safe_push (dwarf2_per_cu_ptr
,
6553 cu
->per_cu
->imported_symtabs
, per_cu
);
6556 case DW_TAG_imported_declaration
:
6557 add_partial_symbol (pdi
, cu
);
6564 /* If the die has a sibling, skip to the sibling. */
6566 pdi
= pdi
->die_sibling
;
6570 /* Functions used to compute the fully scoped name of a partial DIE.
6572 Normally, this is simple. For C++, the parent DIE's fully scoped
6573 name is concatenated with "::" and the partial DIE's name. For
6574 Java, the same thing occurs except that "." is used instead of "::".
6575 Enumerators are an exception; they use the scope of their parent
6576 enumeration type, i.e. the name of the enumeration type is not
6577 prepended to the enumerator.
6579 There are two complexities. One is DW_AT_specification; in this
6580 case "parent" means the parent of the target of the specification,
6581 instead of the direct parent of the DIE. The other is compilers
6582 which do not emit DW_TAG_namespace; in this case we try to guess
6583 the fully qualified name of structure types from their members'
6584 linkage names. This must be done using the DIE's children rather
6585 than the children of any DW_AT_specification target. We only need
6586 to do this for structures at the top level, i.e. if the target of
6587 any DW_AT_specification (if any; otherwise the DIE itself) does not
6590 /* Compute the scope prefix associated with PDI's parent, in
6591 compilation unit CU. The result will be allocated on CU's
6592 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6593 field. NULL is returned if no prefix is necessary. */
6595 partial_die_parent_scope (struct partial_die_info
*pdi
,
6596 struct dwarf2_cu
*cu
)
6598 const char *grandparent_scope
;
6599 struct partial_die_info
*parent
, *real_pdi
;
6601 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6602 then this means the parent of the specification DIE. */
6605 while (real_pdi
->has_specification
)
6606 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
6607 real_pdi
->spec_is_dwz
, cu
);
6609 parent
= real_pdi
->die_parent
;
6613 if (parent
->scope_set
)
6614 return parent
->scope
;
6616 fixup_partial_die (parent
, cu
);
6618 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
6620 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6621 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6622 Work around this problem here. */
6623 if (cu
->language
== language_cplus
6624 && parent
->tag
== DW_TAG_namespace
6625 && strcmp (parent
->name
, "::") == 0
6626 && grandparent_scope
== NULL
)
6628 parent
->scope
= NULL
;
6629 parent
->scope_set
= 1;
6633 if (pdi
->tag
== DW_TAG_enumerator
)
6634 /* Enumerators should not get the name of the enumeration as a prefix. */
6635 parent
->scope
= grandparent_scope
;
6636 else if (parent
->tag
== DW_TAG_namespace
6637 || parent
->tag
== DW_TAG_module
6638 || parent
->tag
== DW_TAG_structure_type
6639 || parent
->tag
== DW_TAG_class_type
6640 || parent
->tag
== DW_TAG_interface_type
6641 || parent
->tag
== DW_TAG_union_type
6642 || parent
->tag
== DW_TAG_enumeration_type
)
6644 if (grandparent_scope
== NULL
)
6645 parent
->scope
= parent
->name
;
6647 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
6649 parent
->name
, 0, cu
);
6653 /* FIXME drow/2004-04-01: What should we be doing with
6654 function-local names? For partial symbols, we should probably be
6656 complaint (&symfile_complaints
,
6657 _("unhandled containing DIE tag %d for DIE at %d"),
6658 parent
->tag
, pdi
->offset
.sect_off
);
6659 parent
->scope
= grandparent_scope
;
6662 parent
->scope_set
= 1;
6663 return parent
->scope
;
6666 /* Return the fully scoped name associated with PDI, from compilation unit
6667 CU. The result will be allocated with malloc. */
6670 partial_die_full_name (struct partial_die_info
*pdi
,
6671 struct dwarf2_cu
*cu
)
6673 const char *parent_scope
;
6675 /* If this is a template instantiation, we can not work out the
6676 template arguments from partial DIEs. So, unfortunately, we have
6677 to go through the full DIEs. At least any work we do building
6678 types here will be reused if full symbols are loaded later. */
6679 if (pdi
->has_template_arguments
)
6681 fixup_partial_die (pdi
, cu
);
6683 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
6685 struct die_info
*die
;
6686 struct attribute attr
;
6687 struct dwarf2_cu
*ref_cu
= cu
;
6689 /* DW_FORM_ref_addr is using section offset. */
6691 attr
.form
= DW_FORM_ref_addr
;
6692 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
6693 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
6695 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
6699 parent_scope
= partial_die_parent_scope (pdi
, cu
);
6700 if (parent_scope
== NULL
)
6703 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
6707 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
6709 struct objfile
*objfile
= cu
->objfile
;
6711 const char *actual_name
= NULL
;
6713 char *built_actual_name
;
6715 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6717 built_actual_name
= partial_die_full_name (pdi
, cu
);
6718 if (built_actual_name
!= NULL
)
6719 actual_name
= built_actual_name
;
6721 if (actual_name
== NULL
)
6722 actual_name
= pdi
->name
;
6726 case DW_TAG_subprogram
:
6727 if (pdi
->is_external
|| cu
->language
== language_ada
)
6729 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6730 of the global scope. But in Ada, we want to be able to access
6731 nested procedures globally. So all Ada subprograms are stored
6732 in the global scope. */
6733 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6734 mst_text, objfile); */
6735 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6736 built_actual_name
!= NULL
,
6737 VAR_DOMAIN
, LOC_BLOCK
,
6738 &objfile
->global_psymbols
,
6739 0, pdi
->lowpc
+ baseaddr
,
6740 cu
->language
, objfile
);
6744 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6745 mst_file_text, objfile); */
6746 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6747 built_actual_name
!= NULL
,
6748 VAR_DOMAIN
, LOC_BLOCK
,
6749 &objfile
->static_psymbols
,
6750 0, pdi
->lowpc
+ baseaddr
,
6751 cu
->language
, objfile
);
6754 case DW_TAG_constant
:
6756 struct psymbol_allocation_list
*list
;
6758 if (pdi
->is_external
)
6759 list
= &objfile
->global_psymbols
;
6761 list
= &objfile
->static_psymbols
;
6762 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6763 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
6764 list
, 0, 0, cu
->language
, objfile
);
6767 case DW_TAG_variable
:
6769 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
6773 && !dwarf2_per_objfile
->has_section_at_zero
)
6775 /* A global or static variable may also have been stripped
6776 out by the linker if unused, in which case its address
6777 will be nullified; do not add such variables into partial
6778 symbol table then. */
6780 else if (pdi
->is_external
)
6783 Don't enter into the minimal symbol tables as there is
6784 a minimal symbol table entry from the ELF symbols already.
6785 Enter into partial symbol table if it has a location
6786 descriptor or a type.
6787 If the location descriptor is missing, new_symbol will create
6788 a LOC_UNRESOLVED symbol, the address of the variable will then
6789 be determined from the minimal symbol table whenever the variable
6791 The address for the partial symbol table entry is not
6792 used by GDB, but it comes in handy for debugging partial symbol
6795 if (pdi
->d
.locdesc
|| pdi
->has_type
)
6796 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6797 built_actual_name
!= NULL
,
6798 VAR_DOMAIN
, LOC_STATIC
,
6799 &objfile
->global_psymbols
,
6801 cu
->language
, objfile
);
6805 /* Static Variable. Skip symbols without location descriptors. */
6806 if (pdi
->d
.locdesc
== NULL
)
6808 xfree (built_actual_name
);
6811 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6812 mst_file_data, objfile); */
6813 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6814 built_actual_name
!= NULL
,
6815 VAR_DOMAIN
, LOC_STATIC
,
6816 &objfile
->static_psymbols
,
6818 cu
->language
, objfile
);
6821 case DW_TAG_typedef
:
6822 case DW_TAG_base_type
:
6823 case DW_TAG_subrange_type
:
6824 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6825 built_actual_name
!= NULL
,
6826 VAR_DOMAIN
, LOC_TYPEDEF
,
6827 &objfile
->static_psymbols
,
6828 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6830 case DW_TAG_imported_declaration
:
6831 case DW_TAG_namespace
:
6832 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6833 built_actual_name
!= NULL
,
6834 VAR_DOMAIN
, LOC_TYPEDEF
,
6835 &objfile
->global_psymbols
,
6836 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6839 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6840 built_actual_name
!= NULL
,
6841 MODULE_DOMAIN
, LOC_TYPEDEF
,
6842 &objfile
->global_psymbols
,
6843 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6845 case DW_TAG_class_type
:
6846 case DW_TAG_interface_type
:
6847 case DW_TAG_structure_type
:
6848 case DW_TAG_union_type
:
6849 case DW_TAG_enumeration_type
:
6850 /* Skip external references. The DWARF standard says in the section
6851 about "Structure, Union, and Class Type Entries": "An incomplete
6852 structure, union or class type is represented by a structure,
6853 union or class entry that does not have a byte size attribute
6854 and that has a DW_AT_declaration attribute." */
6855 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
6857 xfree (built_actual_name
);
6861 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
6862 static vs. global. */
6863 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6864 built_actual_name
!= NULL
,
6865 STRUCT_DOMAIN
, LOC_TYPEDEF
,
6866 (cu
->language
== language_cplus
6867 || cu
->language
== language_java
)
6868 ? &objfile
->global_psymbols
6869 : &objfile
->static_psymbols
,
6870 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6873 case DW_TAG_enumerator
:
6874 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6875 built_actual_name
!= NULL
,
6876 VAR_DOMAIN
, LOC_CONST
,
6877 (cu
->language
== language_cplus
6878 || cu
->language
== language_java
)
6879 ? &objfile
->global_psymbols
6880 : &objfile
->static_psymbols
,
6881 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6887 xfree (built_actual_name
);
6890 /* Read a partial die corresponding to a namespace; also, add a symbol
6891 corresponding to that namespace to the symbol table. NAMESPACE is
6892 the name of the enclosing namespace. */
6895 add_partial_namespace (struct partial_die_info
*pdi
,
6896 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6897 int need_pc
, struct dwarf2_cu
*cu
)
6899 /* Add a symbol for the namespace. */
6901 add_partial_symbol (pdi
, cu
);
6903 /* Now scan partial symbols in that namespace. */
6905 if (pdi
->has_children
)
6906 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
6909 /* Read a partial die corresponding to a Fortran module. */
6912 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
6913 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
6915 /* Add a symbol for the namespace. */
6917 add_partial_symbol (pdi
, cu
);
6919 /* Now scan partial symbols in that module. */
6921 if (pdi
->has_children
)
6922 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
6925 /* Read a partial die corresponding to a subprogram and create a partial
6926 symbol for that subprogram. When the CU language allows it, this
6927 routine also defines a partial symbol for each nested subprogram
6928 that this subprogram contains.
6930 DIE my also be a lexical block, in which case we simply search
6931 recursively for suprograms defined inside that lexical block.
6932 Again, this is only performed when the CU language allows this
6933 type of definitions. */
6936 add_partial_subprogram (struct partial_die_info
*pdi
,
6937 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6938 int need_pc
, struct dwarf2_cu
*cu
)
6940 if (pdi
->tag
== DW_TAG_subprogram
)
6942 if (pdi
->has_pc_info
)
6944 if (pdi
->lowpc
< *lowpc
)
6945 *lowpc
= pdi
->lowpc
;
6946 if (pdi
->highpc
> *highpc
)
6947 *highpc
= pdi
->highpc
;
6951 struct objfile
*objfile
= cu
->objfile
;
6953 baseaddr
= ANOFFSET (objfile
->section_offsets
,
6954 SECT_OFF_TEXT (objfile
));
6955 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6956 pdi
->lowpc
+ baseaddr
,
6957 pdi
->highpc
- 1 + baseaddr
,
6958 cu
->per_cu
->v
.psymtab
);
6962 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
6964 if (!pdi
->is_declaration
)
6965 /* Ignore subprogram DIEs that do not have a name, they are
6966 illegal. Do not emit a complaint at this point, we will
6967 do so when we convert this psymtab into a symtab. */
6969 add_partial_symbol (pdi
, cu
);
6973 if (! pdi
->has_children
)
6976 if (cu
->language
== language_ada
)
6978 pdi
= pdi
->die_child
;
6981 fixup_partial_die (pdi
, cu
);
6982 if (pdi
->tag
== DW_TAG_subprogram
6983 || pdi
->tag
== DW_TAG_lexical_block
)
6984 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
6985 pdi
= pdi
->die_sibling
;
6990 /* Read a partial die corresponding to an enumeration type. */
6993 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
6994 struct dwarf2_cu
*cu
)
6996 struct partial_die_info
*pdi
;
6998 if (enum_pdi
->name
!= NULL
)
6999 add_partial_symbol (enum_pdi
, cu
);
7001 pdi
= enum_pdi
->die_child
;
7004 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
7005 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
7007 add_partial_symbol (pdi
, cu
);
7008 pdi
= pdi
->die_sibling
;
7012 /* Return the initial uleb128 in the die at INFO_PTR. */
7015 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
7017 unsigned int bytes_read
;
7019 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7022 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7023 Return the corresponding abbrev, or NULL if the number is zero (indicating
7024 an empty DIE). In either case *BYTES_READ will be set to the length of
7025 the initial number. */
7027 static struct abbrev_info
*
7028 peek_die_abbrev (const gdb_byte
*info_ptr
, unsigned int *bytes_read
,
7029 struct dwarf2_cu
*cu
)
7031 bfd
*abfd
= cu
->objfile
->obfd
;
7032 unsigned int abbrev_number
;
7033 struct abbrev_info
*abbrev
;
7035 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
7037 if (abbrev_number
== 0)
7040 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
7043 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
7044 abbrev_number
, bfd_get_filename (abfd
));
7050 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7051 Returns a pointer to the end of a series of DIEs, terminated by an empty
7052 DIE. Any children of the skipped DIEs will also be skipped. */
7054 static const gdb_byte
*
7055 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
7057 struct dwarf2_cu
*cu
= reader
->cu
;
7058 struct abbrev_info
*abbrev
;
7059 unsigned int bytes_read
;
7063 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
7065 return info_ptr
+ bytes_read
;
7067 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
7071 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7072 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7073 abbrev corresponding to that skipped uleb128 should be passed in
7074 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7077 static const gdb_byte
*
7078 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
7079 struct abbrev_info
*abbrev
)
7081 unsigned int bytes_read
;
7082 struct attribute attr
;
7083 bfd
*abfd
= reader
->abfd
;
7084 struct dwarf2_cu
*cu
= reader
->cu
;
7085 const gdb_byte
*buffer
= reader
->buffer
;
7086 const gdb_byte
*buffer_end
= reader
->buffer_end
;
7087 const gdb_byte
*start_info_ptr
= info_ptr
;
7088 unsigned int form
, i
;
7090 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
7092 /* The only abbrev we care about is DW_AT_sibling. */
7093 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
7095 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
7096 if (attr
.form
== DW_FORM_ref_addr
)
7097 complaint (&symfile_complaints
,
7098 _("ignoring absolute DW_AT_sibling"));
7101 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
7102 const gdb_byte
*sibling_ptr
= buffer
+ off
;
7104 if (sibling_ptr
< info_ptr
)
7105 complaint (&symfile_complaints
,
7106 _("DW_AT_sibling points backwards"));
7112 /* If it isn't DW_AT_sibling, skip this attribute. */
7113 form
= abbrev
->attrs
[i
].form
;
7117 case DW_FORM_ref_addr
:
7118 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7119 and later it is offset sized. */
7120 if (cu
->header
.version
== 2)
7121 info_ptr
+= cu
->header
.addr_size
;
7123 info_ptr
+= cu
->header
.offset_size
;
7125 case DW_FORM_GNU_ref_alt
:
7126 info_ptr
+= cu
->header
.offset_size
;
7129 info_ptr
+= cu
->header
.addr_size
;
7136 case DW_FORM_flag_present
:
7148 case DW_FORM_ref_sig8
:
7151 case DW_FORM_string
:
7152 read_direct_string (abfd
, info_ptr
, &bytes_read
);
7153 info_ptr
+= bytes_read
;
7155 case DW_FORM_sec_offset
:
7157 case DW_FORM_GNU_strp_alt
:
7158 info_ptr
+= cu
->header
.offset_size
;
7160 case DW_FORM_exprloc
:
7162 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7163 info_ptr
+= bytes_read
;
7165 case DW_FORM_block1
:
7166 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
7168 case DW_FORM_block2
:
7169 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
7171 case DW_FORM_block4
:
7172 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
7176 case DW_FORM_ref_udata
:
7177 case DW_FORM_GNU_addr_index
:
7178 case DW_FORM_GNU_str_index
:
7179 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
7181 case DW_FORM_indirect
:
7182 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7183 info_ptr
+= bytes_read
;
7184 /* We need to continue parsing from here, so just go back to
7186 goto skip_attribute
;
7189 error (_("Dwarf Error: Cannot handle %s "
7190 "in DWARF reader [in module %s]"),
7191 dwarf_form_name (form
),
7192 bfd_get_filename (abfd
));
7196 if (abbrev
->has_children
)
7197 return skip_children (reader
, info_ptr
);
7202 /* Locate ORIG_PDI's sibling.
7203 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7205 static const gdb_byte
*
7206 locate_pdi_sibling (const struct die_reader_specs
*reader
,
7207 struct partial_die_info
*orig_pdi
,
7208 const gdb_byte
*info_ptr
)
7210 /* Do we know the sibling already? */
7212 if (orig_pdi
->sibling
)
7213 return orig_pdi
->sibling
;
7215 /* Are there any children to deal with? */
7217 if (!orig_pdi
->has_children
)
7220 /* Skip the children the long way. */
7222 return skip_children (reader
, info_ptr
);
7225 /* Expand this partial symbol table into a full symbol table. SELF is
7229 dwarf2_read_symtab (struct partial_symtab
*self
,
7230 struct objfile
*objfile
)
7234 warning (_("bug: psymtab for %s is already read in."),
7241 printf_filtered (_("Reading in symbols for %s..."),
7243 gdb_flush (gdb_stdout
);
7246 /* Restore our global data. */
7247 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
7249 /* If this psymtab is constructed from a debug-only objfile, the
7250 has_section_at_zero flag will not necessarily be correct. We
7251 can get the correct value for this flag by looking at the data
7252 associated with the (presumably stripped) associated objfile. */
7253 if (objfile
->separate_debug_objfile_backlink
)
7255 struct dwarf2_per_objfile
*dpo_backlink
7256 = objfile_data (objfile
->separate_debug_objfile_backlink
,
7257 dwarf2_objfile_data_key
);
7259 dwarf2_per_objfile
->has_section_at_zero
7260 = dpo_backlink
->has_section_at_zero
;
7263 dwarf2_per_objfile
->reading_partial_symbols
= 0;
7265 psymtab_to_symtab_1 (self
);
7267 /* Finish up the debug error message. */
7269 printf_filtered (_("done.\n"));
7272 process_cu_includes ();
7275 /* Reading in full CUs. */
7277 /* Add PER_CU to the queue. */
7280 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
7281 enum language pretend_language
)
7283 struct dwarf2_queue_item
*item
;
7286 item
= xmalloc (sizeof (*item
));
7287 item
->per_cu
= per_cu
;
7288 item
->pretend_language
= pretend_language
;
7291 if (dwarf2_queue
== NULL
)
7292 dwarf2_queue
= item
;
7294 dwarf2_queue_tail
->next
= item
;
7296 dwarf2_queue_tail
= item
;
7299 /* If PER_CU is not yet queued, add it to the queue.
7300 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7302 The result is non-zero if PER_CU was queued, otherwise the result is zero
7303 meaning either PER_CU is already queued or it is already loaded.
7305 N.B. There is an invariant here that if a CU is queued then it is loaded.
7306 The caller is required to load PER_CU if we return non-zero. */
7309 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
7310 struct dwarf2_per_cu_data
*per_cu
,
7311 enum language pretend_language
)
7313 /* We may arrive here during partial symbol reading, if we need full
7314 DIEs to process an unusual case (e.g. template arguments). Do
7315 not queue PER_CU, just tell our caller to load its DIEs. */
7316 if (dwarf2_per_objfile
->reading_partial_symbols
)
7318 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
7323 /* Mark the dependence relation so that we don't flush PER_CU
7325 if (dependent_cu
!= NULL
)
7326 dwarf2_add_dependence (dependent_cu
, per_cu
);
7328 /* If it's already on the queue, we have nothing to do. */
7332 /* If the compilation unit is already loaded, just mark it as
7334 if (per_cu
->cu
!= NULL
)
7336 per_cu
->cu
->last_used
= 0;
7340 /* Add it to the queue. */
7341 queue_comp_unit (per_cu
, pretend_language
);
7346 /* Process the queue. */
7349 process_queue (void)
7351 struct dwarf2_queue_item
*item
, *next_item
;
7353 if (dwarf2_read_debug
)
7355 fprintf_unfiltered (gdb_stdlog
,
7356 "Expanding one or more symtabs of objfile %s ...\n",
7357 objfile_name (dwarf2_per_objfile
->objfile
));
7360 /* The queue starts out with one item, but following a DIE reference
7361 may load a new CU, adding it to the end of the queue. */
7362 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
7364 if (dwarf2_per_objfile
->using_index
7365 ? !item
->per_cu
->v
.quick
->symtab
7366 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
7368 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
7369 unsigned int debug_print_threshold
;
7372 if (per_cu
->is_debug_types
)
7374 struct signatured_type
*sig_type
=
7375 (struct signatured_type
*) per_cu
;
7377 sprintf (buf
, "TU %s at offset 0x%x",
7378 hex_string (sig_type
->signature
),
7379 per_cu
->offset
.sect_off
);
7380 /* There can be 100s of TUs.
7381 Only print them in verbose mode. */
7382 debug_print_threshold
= 2;
7386 sprintf (buf
, "CU at offset 0x%x", per_cu
->offset
.sect_off
);
7387 debug_print_threshold
= 1;
7390 if (dwarf2_read_debug
>= debug_print_threshold
)
7391 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
7393 if (per_cu
->is_debug_types
)
7394 process_full_type_unit (per_cu
, item
->pretend_language
);
7396 process_full_comp_unit (per_cu
, item
->pretend_language
);
7398 if (dwarf2_read_debug
>= debug_print_threshold
)
7399 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
7402 item
->per_cu
->queued
= 0;
7403 next_item
= item
->next
;
7407 dwarf2_queue_tail
= NULL
;
7409 if (dwarf2_read_debug
)
7411 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
7412 objfile_name (dwarf2_per_objfile
->objfile
));
7416 /* Free all allocated queue entries. This function only releases anything if
7417 an error was thrown; if the queue was processed then it would have been
7418 freed as we went along. */
7421 dwarf2_release_queue (void *dummy
)
7423 struct dwarf2_queue_item
*item
, *last
;
7425 item
= dwarf2_queue
;
7428 /* Anything still marked queued is likely to be in an
7429 inconsistent state, so discard it. */
7430 if (item
->per_cu
->queued
)
7432 if (item
->per_cu
->cu
!= NULL
)
7433 free_one_cached_comp_unit (item
->per_cu
);
7434 item
->per_cu
->queued
= 0;
7442 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
7445 /* Read in full symbols for PST, and anything it depends on. */
7448 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
7450 struct dwarf2_per_cu_data
*per_cu
;
7456 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
7457 if (!pst
->dependencies
[i
]->readin
7458 && pst
->dependencies
[i
]->user
== NULL
)
7460 /* Inform about additional files that need to be read in. */
7463 /* FIXME: i18n: Need to make this a single string. */
7464 fputs_filtered (" ", gdb_stdout
);
7466 fputs_filtered ("and ", gdb_stdout
);
7468 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
7469 wrap_here (""); /* Flush output. */
7470 gdb_flush (gdb_stdout
);
7472 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
7475 per_cu
= pst
->read_symtab_private
;
7479 /* It's an include file, no symbols to read for it.
7480 Everything is in the parent symtab. */
7485 dw2_do_instantiate_symtab (per_cu
);
7488 /* Trivial hash function for die_info: the hash value of a DIE
7489 is its offset in .debug_info for this objfile. */
7492 die_hash (const void *item
)
7494 const struct die_info
*die
= item
;
7496 return die
->offset
.sect_off
;
7499 /* Trivial comparison function for die_info structures: two DIEs
7500 are equal if they have the same offset. */
7503 die_eq (const void *item_lhs
, const void *item_rhs
)
7505 const struct die_info
*die_lhs
= item_lhs
;
7506 const struct die_info
*die_rhs
= item_rhs
;
7508 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
7511 /* die_reader_func for load_full_comp_unit.
7512 This is identical to read_signatured_type_reader,
7513 but is kept separate for now. */
7516 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
7517 const gdb_byte
*info_ptr
,
7518 struct die_info
*comp_unit_die
,
7522 struct dwarf2_cu
*cu
= reader
->cu
;
7523 enum language
*language_ptr
= data
;
7525 gdb_assert (cu
->die_hash
== NULL
);
7527 htab_create_alloc_ex (cu
->header
.length
/ 12,
7531 &cu
->comp_unit_obstack
,
7532 hashtab_obstack_allocate
,
7533 dummy_obstack_deallocate
);
7536 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
7537 &info_ptr
, comp_unit_die
);
7538 cu
->dies
= comp_unit_die
;
7539 /* comp_unit_die is not stored in die_hash, no need. */
7541 /* We try not to read any attributes in this function, because not
7542 all CUs needed for references have been loaded yet, and symbol
7543 table processing isn't initialized. But we have to set the CU language,
7544 or we won't be able to build types correctly.
7545 Similarly, if we do not read the producer, we can not apply
7546 producer-specific interpretation. */
7547 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
7550 /* Load the DIEs associated with PER_CU into memory. */
7553 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7554 enum language pretend_language
)
7556 gdb_assert (! this_cu
->is_debug_types
);
7558 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
7559 load_full_comp_unit_reader
, &pretend_language
);
7562 /* Add a DIE to the delayed physname list. */
7565 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
7566 const char *name
, struct die_info
*die
,
7567 struct dwarf2_cu
*cu
)
7569 struct delayed_method_info mi
;
7571 mi
.fnfield_index
= fnfield_index
;
7575 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
7578 /* A cleanup for freeing the delayed method list. */
7581 free_delayed_list (void *ptr
)
7583 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
7584 if (cu
->method_list
!= NULL
)
7586 VEC_free (delayed_method_info
, cu
->method_list
);
7587 cu
->method_list
= NULL
;
7591 /* Compute the physnames of any methods on the CU's method list.
7593 The computation of method physnames is delayed in order to avoid the
7594 (bad) condition that one of the method's formal parameters is of an as yet
7598 compute_delayed_physnames (struct dwarf2_cu
*cu
)
7601 struct delayed_method_info
*mi
;
7602 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
7604 const char *physname
;
7605 struct fn_fieldlist
*fn_flp
7606 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
7607 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
7608 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
7612 /* Go objects should be embedded in a DW_TAG_module DIE,
7613 and it's not clear if/how imported objects will appear.
7614 To keep Go support simple until that's worked out,
7615 go back through what we've read and create something usable.
7616 We could do this while processing each DIE, and feels kinda cleaner,
7617 but that way is more invasive.
7618 This is to, for example, allow the user to type "p var" or "b main"
7619 without having to specify the package name, and allow lookups
7620 of module.object to work in contexts that use the expression
7624 fixup_go_packaging (struct dwarf2_cu
*cu
)
7626 char *package_name
= NULL
;
7627 struct pending
*list
;
7630 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
7632 for (i
= 0; i
< list
->nsyms
; ++i
)
7634 struct symbol
*sym
= list
->symbol
[i
];
7636 if (SYMBOL_LANGUAGE (sym
) == language_go
7637 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
7639 char *this_package_name
= go_symbol_package_name (sym
);
7641 if (this_package_name
== NULL
)
7643 if (package_name
== NULL
)
7644 package_name
= this_package_name
;
7647 if (strcmp (package_name
, this_package_name
) != 0)
7648 complaint (&symfile_complaints
,
7649 _("Symtab %s has objects from two different Go packages: %s and %s"),
7650 (SYMBOL_SYMTAB (sym
)
7651 ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym
))
7652 : objfile_name (cu
->objfile
)),
7653 this_package_name
, package_name
);
7654 xfree (this_package_name
);
7660 if (package_name
!= NULL
)
7662 struct objfile
*objfile
= cu
->objfile
;
7663 const char *saved_package_name
= obstack_copy0 (&objfile
->objfile_obstack
,
7665 strlen (package_name
));
7666 struct type
*type
= init_type (TYPE_CODE_MODULE
, 0, 0,
7667 saved_package_name
, objfile
);
7670 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7672 sym
= allocate_symbol (objfile
);
7673 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
7674 SYMBOL_SET_NAMES (sym
, saved_package_name
,
7675 strlen (saved_package_name
), 0, objfile
);
7676 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7677 e.g., "main" finds the "main" module and not C's main(). */
7678 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7679 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
7680 SYMBOL_TYPE (sym
) = type
;
7682 add_symbol_to_list (sym
, &global_symbols
);
7684 xfree (package_name
);
7688 /* Return the symtab for PER_CU. This works properly regardless of
7689 whether we're using the index or psymtabs. */
7691 static struct symtab
*
7692 get_symtab (struct dwarf2_per_cu_data
*per_cu
)
7694 return (dwarf2_per_objfile
->using_index
7695 ? per_cu
->v
.quick
->symtab
7696 : per_cu
->v
.psymtab
->symtab
);
7699 /* A helper function for computing the list of all symbol tables
7700 included by PER_CU. */
7703 recursively_compute_inclusions (VEC (symtab_ptr
) **result
,
7704 htab_t all_children
, htab_t all_type_symtabs
,
7705 struct dwarf2_per_cu_data
*per_cu
,
7706 struct symtab
*immediate_parent
)
7710 struct symtab
*symtab
;
7711 struct dwarf2_per_cu_data
*iter
;
7713 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
7716 /* This inclusion and its children have been processed. */
7721 /* Only add a CU if it has a symbol table. */
7722 symtab
= get_symtab (per_cu
);
7725 /* If this is a type unit only add its symbol table if we haven't
7726 seen it yet (type unit per_cu's can share symtabs). */
7727 if (per_cu
->is_debug_types
)
7729 slot
= htab_find_slot (all_type_symtabs
, symtab
, INSERT
);
7733 VEC_safe_push (symtab_ptr
, *result
, symtab
);
7734 if (symtab
->user
== NULL
)
7735 symtab
->user
= immediate_parent
;
7740 VEC_safe_push (symtab_ptr
, *result
, symtab
);
7741 if (symtab
->user
== NULL
)
7742 symtab
->user
= immediate_parent
;
7747 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
7750 recursively_compute_inclusions (result
, all_children
,
7751 all_type_symtabs
, iter
, symtab
);
7755 /* Compute the symtab 'includes' fields for the symtab related to
7759 compute_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
7761 gdb_assert (! per_cu
->is_debug_types
);
7763 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
7766 struct dwarf2_per_cu_data
*per_cu_iter
;
7767 struct symtab
*symtab_iter
;
7768 VEC (symtab_ptr
) *result_symtabs
= NULL
;
7769 htab_t all_children
, all_type_symtabs
;
7770 struct symtab
*symtab
= get_symtab (per_cu
);
7772 /* If we don't have a symtab, we can just skip this case. */
7776 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7777 NULL
, xcalloc
, xfree
);
7778 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7779 NULL
, xcalloc
, xfree
);
7782 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
7786 recursively_compute_inclusions (&result_symtabs
, all_children
,
7787 all_type_symtabs
, per_cu_iter
,
7791 /* Now we have a transitive closure of all the included symtabs. */
7792 len
= VEC_length (symtab_ptr
, result_symtabs
);
7794 = obstack_alloc (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
7795 (len
+ 1) * sizeof (struct symtab
*));
7797 VEC_iterate (symtab_ptr
, result_symtabs
, ix
, symtab_iter
);
7799 symtab
->includes
[ix
] = symtab_iter
;
7800 symtab
->includes
[len
] = NULL
;
7802 VEC_free (symtab_ptr
, result_symtabs
);
7803 htab_delete (all_children
);
7804 htab_delete (all_type_symtabs
);
7808 /* Compute the 'includes' field for the symtabs of all the CUs we just
7812 process_cu_includes (void)
7815 struct dwarf2_per_cu_data
*iter
;
7818 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
7822 if (! iter
->is_debug_types
)
7823 compute_symtab_includes (iter
);
7826 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
7829 /* Generate full symbol information for PER_CU, whose DIEs have
7830 already been loaded into memory. */
7833 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
7834 enum language pretend_language
)
7836 struct dwarf2_cu
*cu
= per_cu
->cu
;
7837 struct objfile
*objfile
= per_cu
->objfile
;
7838 CORE_ADDR lowpc
, highpc
;
7839 struct symtab
*symtab
;
7840 struct cleanup
*back_to
, *delayed_list_cleanup
;
7842 struct block
*static_block
;
7844 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7847 back_to
= make_cleanup (really_free_pendings
, NULL
);
7848 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
7850 cu
->list_in_scope
= &file_symbols
;
7852 cu
->language
= pretend_language
;
7853 cu
->language_defn
= language_def (cu
->language
);
7855 /* Do line number decoding in read_file_scope () */
7856 process_die (cu
->dies
, cu
);
7858 /* For now fudge the Go package. */
7859 if (cu
->language
== language_go
)
7860 fixup_go_packaging (cu
);
7862 /* Now that we have processed all the DIEs in the CU, all the types
7863 should be complete, and it should now be safe to compute all of the
7865 compute_delayed_physnames (cu
);
7866 do_cleanups (delayed_list_cleanup
);
7868 /* Some compilers don't define a DW_AT_high_pc attribute for the
7869 compilation unit. If the DW_AT_high_pc is missing, synthesize
7870 it, by scanning the DIE's below the compilation unit. */
7871 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
7874 = end_symtab_get_static_block (highpc
+ baseaddr
, objfile
, 0, 1);
7876 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
7877 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
7878 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
7879 addrmap to help ensure it has an accurate map of pc values belonging to
7881 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
7883 symtab
= end_symtab_from_static_block (static_block
, objfile
,
7884 SECT_OFF_TEXT (objfile
), 0);
7888 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
7890 /* Set symtab language to language from DW_AT_language. If the
7891 compilation is from a C file generated by language preprocessors, do
7892 not set the language if it was already deduced by start_subfile. */
7893 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
7894 symtab
->language
= cu
->language
;
7896 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
7897 produce DW_AT_location with location lists but it can be possibly
7898 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
7899 there were bugs in prologue debug info, fixed later in GCC-4.5
7900 by "unwind info for epilogues" patch (which is not directly related).
7902 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
7903 needed, it would be wrong due to missing DW_AT_producer there.
7905 Still one can confuse GDB by using non-standard GCC compilation
7906 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
7908 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
7909 symtab
->locations_valid
= 1;
7911 if (gcc_4_minor
>= 5)
7912 symtab
->epilogue_unwind_valid
= 1;
7914 symtab
->call_site_htab
= cu
->call_site_htab
;
7917 if (dwarf2_per_objfile
->using_index
)
7918 per_cu
->v
.quick
->symtab
= symtab
;
7921 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
7922 pst
->symtab
= symtab
;
7926 /* Push it for inclusion processing later. */
7927 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
7929 do_cleanups (back_to
);
7932 /* Generate full symbol information for type unit PER_CU, whose DIEs have
7933 already been loaded into memory. */
7936 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
7937 enum language pretend_language
)
7939 struct dwarf2_cu
*cu
= per_cu
->cu
;
7940 struct objfile
*objfile
= per_cu
->objfile
;
7941 struct symtab
*symtab
;
7942 struct cleanup
*back_to
, *delayed_list_cleanup
;
7943 struct signatured_type
*sig_type
;
7945 gdb_assert (per_cu
->is_debug_types
);
7946 sig_type
= (struct signatured_type
*) per_cu
;
7949 back_to
= make_cleanup (really_free_pendings
, NULL
);
7950 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
7952 cu
->list_in_scope
= &file_symbols
;
7954 cu
->language
= pretend_language
;
7955 cu
->language_defn
= language_def (cu
->language
);
7957 /* The symbol tables are set up in read_type_unit_scope. */
7958 process_die (cu
->dies
, cu
);
7960 /* For now fudge the Go package. */
7961 if (cu
->language
== language_go
)
7962 fixup_go_packaging (cu
);
7964 /* Now that we have processed all the DIEs in the CU, all the types
7965 should be complete, and it should now be safe to compute all of the
7967 compute_delayed_physnames (cu
);
7968 do_cleanups (delayed_list_cleanup
);
7970 /* TUs share symbol tables.
7971 If this is the first TU to use this symtab, complete the construction
7972 of it with end_expandable_symtab. Otherwise, complete the addition of
7973 this TU's symbols to the existing symtab. */
7974 if (sig_type
->type_unit_group
->primary_symtab
== NULL
)
7976 symtab
= end_expandable_symtab (0, objfile
, SECT_OFF_TEXT (objfile
));
7977 sig_type
->type_unit_group
->primary_symtab
= symtab
;
7981 /* Set symtab language to language from DW_AT_language. If the
7982 compilation is from a C file generated by language preprocessors,
7983 do not set the language if it was already deduced by
7985 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
7986 symtab
->language
= cu
->language
;
7991 augment_type_symtab (objfile
,
7992 sig_type
->type_unit_group
->primary_symtab
);
7993 symtab
= sig_type
->type_unit_group
->primary_symtab
;
7996 if (dwarf2_per_objfile
->using_index
)
7997 per_cu
->v
.quick
->symtab
= symtab
;
8000 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8001 pst
->symtab
= symtab
;
8005 do_cleanups (back_to
);
8008 /* Process an imported unit DIE. */
8011 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8013 struct attribute
*attr
;
8015 /* For now we don't handle imported units in type units. */
8016 if (cu
->per_cu
->is_debug_types
)
8018 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8019 " supported in type units [in module %s]"),
8020 objfile_name (cu
->objfile
));
8023 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8026 struct dwarf2_per_cu_data
*per_cu
;
8027 struct symtab
*imported_symtab
;
8031 offset
= dwarf2_get_ref_die_offset (attr
);
8032 is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
8033 per_cu
= dwarf2_find_containing_comp_unit (offset
, is_dwz
, cu
->objfile
);
8035 /* If necessary, add it to the queue and load its DIEs. */
8036 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
8037 load_full_comp_unit (per_cu
, cu
->language
);
8039 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8044 /* Reset the in_process bit of a die. */
8047 reset_die_in_process (void *arg
)
8049 struct die_info
*die
= arg
;
8051 die
->in_process
= 0;
8054 /* Process a die and its children. */
8057 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8059 struct cleanup
*in_process
;
8061 /* We should only be processing those not already in process. */
8062 gdb_assert (!die
->in_process
);
8064 die
->in_process
= 1;
8065 in_process
= make_cleanup (reset_die_in_process
,die
);
8069 case DW_TAG_padding
:
8071 case DW_TAG_compile_unit
:
8072 case DW_TAG_partial_unit
:
8073 read_file_scope (die
, cu
);
8075 case DW_TAG_type_unit
:
8076 read_type_unit_scope (die
, cu
);
8078 case DW_TAG_subprogram
:
8079 case DW_TAG_inlined_subroutine
:
8080 read_func_scope (die
, cu
);
8082 case DW_TAG_lexical_block
:
8083 case DW_TAG_try_block
:
8084 case DW_TAG_catch_block
:
8085 read_lexical_block_scope (die
, cu
);
8087 case DW_TAG_GNU_call_site
:
8088 read_call_site_scope (die
, cu
);
8090 case DW_TAG_class_type
:
8091 case DW_TAG_interface_type
:
8092 case DW_TAG_structure_type
:
8093 case DW_TAG_union_type
:
8094 process_structure_scope (die
, cu
);
8096 case DW_TAG_enumeration_type
:
8097 process_enumeration_scope (die
, cu
);
8100 /* These dies have a type, but processing them does not create
8101 a symbol or recurse to process the children. Therefore we can
8102 read them on-demand through read_type_die. */
8103 case DW_TAG_subroutine_type
:
8104 case DW_TAG_set_type
:
8105 case DW_TAG_array_type
:
8106 case DW_TAG_pointer_type
:
8107 case DW_TAG_ptr_to_member_type
:
8108 case DW_TAG_reference_type
:
8109 case DW_TAG_string_type
:
8112 case DW_TAG_base_type
:
8113 case DW_TAG_subrange_type
:
8114 case DW_TAG_typedef
:
8115 /* Add a typedef symbol for the type definition, if it has a
8117 new_symbol (die
, read_type_die (die
, cu
), cu
);
8119 case DW_TAG_common_block
:
8120 read_common_block (die
, cu
);
8122 case DW_TAG_common_inclusion
:
8124 case DW_TAG_namespace
:
8125 cu
->processing_has_namespace_info
= 1;
8126 read_namespace (die
, cu
);
8129 cu
->processing_has_namespace_info
= 1;
8130 read_module (die
, cu
);
8132 case DW_TAG_imported_declaration
:
8133 cu
->processing_has_namespace_info
= 1;
8134 if (read_namespace_alias (die
, cu
))
8136 /* The declaration is not a global namespace alias: fall through. */
8137 case DW_TAG_imported_module
:
8138 cu
->processing_has_namespace_info
= 1;
8139 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
8140 || cu
->language
!= language_fortran
))
8141 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
8142 dwarf_tag_name (die
->tag
));
8143 read_import_statement (die
, cu
);
8146 case DW_TAG_imported_unit
:
8147 process_imported_unit_die (die
, cu
);
8151 new_symbol (die
, NULL
, cu
);
8155 do_cleanups (in_process
);
8158 /* DWARF name computation. */
8160 /* A helper function for dwarf2_compute_name which determines whether DIE
8161 needs to have the name of the scope prepended to the name listed in the
8165 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8167 struct attribute
*attr
;
8171 case DW_TAG_namespace
:
8172 case DW_TAG_typedef
:
8173 case DW_TAG_class_type
:
8174 case DW_TAG_interface_type
:
8175 case DW_TAG_structure_type
:
8176 case DW_TAG_union_type
:
8177 case DW_TAG_enumeration_type
:
8178 case DW_TAG_enumerator
:
8179 case DW_TAG_subprogram
:
8181 case DW_TAG_imported_declaration
:
8184 case DW_TAG_variable
:
8185 case DW_TAG_constant
:
8186 /* We only need to prefix "globally" visible variables. These include
8187 any variable marked with DW_AT_external or any variable that
8188 lives in a namespace. [Variables in anonymous namespaces
8189 require prefixing, but they are not DW_AT_external.] */
8191 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
8193 struct dwarf2_cu
*spec_cu
= cu
;
8195 return die_needs_namespace (die_specification (die
, &spec_cu
),
8199 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
8200 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
8201 && die
->parent
->tag
!= DW_TAG_module
)
8203 /* A variable in a lexical block of some kind does not need a
8204 namespace, even though in C++ such variables may be external
8205 and have a mangled name. */
8206 if (die
->parent
->tag
== DW_TAG_lexical_block
8207 || die
->parent
->tag
== DW_TAG_try_block
8208 || die
->parent
->tag
== DW_TAG_catch_block
8209 || die
->parent
->tag
== DW_TAG_subprogram
)
8218 /* Retrieve the last character from a mem_file. */
8221 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
8223 char *last_char_p
= (char *) object
;
8226 *last_char_p
= buffer
[length
- 1];
8229 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8230 compute the physname for the object, which include a method's:
8231 - formal parameters (C++/Java),
8232 - receiver type (Go),
8233 - return type (Java).
8235 The term "physname" is a bit confusing.
8236 For C++, for example, it is the demangled name.
8237 For Go, for example, it's the mangled name.
8239 For Ada, return the DIE's linkage name rather than the fully qualified
8240 name. PHYSNAME is ignored..
8242 The result is allocated on the objfile_obstack and canonicalized. */
8245 dwarf2_compute_name (const char *name
,
8246 struct die_info
*die
, struct dwarf2_cu
*cu
,
8249 struct objfile
*objfile
= cu
->objfile
;
8252 name
= dwarf2_name (die
, cu
);
8254 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8255 compute it by typename_concat inside GDB. */
8256 if (cu
->language
== language_ada
8257 || (cu
->language
== language_fortran
&& physname
))
8259 /* For Ada unit, we prefer the linkage name over the name, as
8260 the former contains the exported name, which the user expects
8261 to be able to reference. Ideally, we want the user to be able
8262 to reference this entity using either natural or linkage name,
8263 but we haven't started looking at this enhancement yet. */
8264 struct attribute
*attr
;
8266 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8268 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8269 if (attr
&& DW_STRING (attr
))
8270 return DW_STRING (attr
);
8273 /* These are the only languages we know how to qualify names in. */
8275 && (cu
->language
== language_cplus
|| cu
->language
== language_java
8276 || cu
->language
== language_fortran
))
8278 if (die_needs_namespace (die
, cu
))
8282 struct ui_file
*buf
;
8284 prefix
= determine_prefix (die
, cu
);
8285 buf
= mem_fileopen ();
8286 if (*prefix
!= '\0')
8288 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
8291 fputs_unfiltered (prefixed_name
, buf
);
8292 xfree (prefixed_name
);
8295 fputs_unfiltered (name
, buf
);
8297 /* Template parameters may be specified in the DIE's DW_AT_name, or
8298 as children with DW_TAG_template_type_param or
8299 DW_TAG_value_type_param. If the latter, add them to the name
8300 here. If the name already has template parameters, then
8301 skip this step; some versions of GCC emit both, and
8302 it is more efficient to use the pre-computed name.
8304 Something to keep in mind about this process: it is very
8305 unlikely, or in some cases downright impossible, to produce
8306 something that will match the mangled name of a function.
8307 If the definition of the function has the same debug info,
8308 we should be able to match up with it anyway. But fallbacks
8309 using the minimal symbol, for instance to find a method
8310 implemented in a stripped copy of libstdc++, will not work.
8311 If we do not have debug info for the definition, we will have to
8312 match them up some other way.
8314 When we do name matching there is a related problem with function
8315 templates; two instantiated function templates are allowed to
8316 differ only by their return types, which we do not add here. */
8318 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
8320 struct attribute
*attr
;
8321 struct die_info
*child
;
8324 die
->building_fullname
= 1;
8326 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
8330 const gdb_byte
*bytes
;
8331 struct dwarf2_locexpr_baton
*baton
;
8334 if (child
->tag
!= DW_TAG_template_type_param
8335 && child
->tag
!= DW_TAG_template_value_param
)
8340 fputs_unfiltered ("<", buf
);
8344 fputs_unfiltered (", ", buf
);
8346 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
8349 complaint (&symfile_complaints
,
8350 _("template parameter missing DW_AT_type"));
8351 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
8354 type
= die_type (child
, cu
);
8356 if (child
->tag
== DW_TAG_template_type_param
)
8358 c_print_type (type
, "", buf
, -1, 0, &type_print_raw_options
);
8362 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
8365 complaint (&symfile_complaints
,
8366 _("template parameter missing "
8367 "DW_AT_const_value"));
8368 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
8372 dwarf2_const_value_attr (attr
, type
, name
,
8373 &cu
->comp_unit_obstack
, cu
,
8374 &value
, &bytes
, &baton
);
8376 if (TYPE_NOSIGN (type
))
8377 /* GDB prints characters as NUMBER 'CHAR'. If that's
8378 changed, this can use value_print instead. */
8379 c_printchar (value
, type
, buf
);
8382 struct value_print_options opts
;
8385 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
8389 else if (bytes
!= NULL
)
8391 v
= allocate_value (type
);
8392 memcpy (value_contents_writeable (v
), bytes
,
8393 TYPE_LENGTH (type
));
8396 v
= value_from_longest (type
, value
);
8398 /* Specify decimal so that we do not depend on
8400 get_formatted_print_options (&opts
, 'd');
8402 value_print (v
, buf
, &opts
);
8408 die
->building_fullname
= 0;
8412 /* Close the argument list, with a space if necessary
8413 (nested templates). */
8414 char last_char
= '\0';
8415 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
8416 if (last_char
== '>')
8417 fputs_unfiltered (" >", buf
);
8419 fputs_unfiltered (">", buf
);
8423 /* For Java and C++ methods, append formal parameter type
8424 information, if PHYSNAME. */
8426 if (physname
&& die
->tag
== DW_TAG_subprogram
8427 && (cu
->language
== language_cplus
8428 || cu
->language
== language_java
))
8430 struct type
*type
= read_type_die (die
, cu
);
8432 c_type_print_args (type
, buf
, 1, cu
->language
,
8433 &type_print_raw_options
);
8435 if (cu
->language
== language_java
)
8437 /* For java, we must append the return type to method
8439 if (die
->tag
== DW_TAG_subprogram
)
8440 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
8441 0, 0, &type_print_raw_options
);
8443 else if (cu
->language
== language_cplus
)
8445 /* Assume that an artificial first parameter is
8446 "this", but do not crash if it is not. RealView
8447 marks unnamed (and thus unused) parameters as
8448 artificial; there is no way to differentiate
8450 if (TYPE_NFIELDS (type
) > 0
8451 && TYPE_FIELD_ARTIFICIAL (type
, 0)
8452 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
8453 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
8455 fputs_unfiltered (" const", buf
);
8459 name
= ui_file_obsavestring (buf
, &objfile
->objfile_obstack
,
8461 ui_file_delete (buf
);
8463 if (cu
->language
== language_cplus
)
8466 = dwarf2_canonicalize_name (name
, cu
,
8467 &objfile
->objfile_obstack
);
8478 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8479 If scope qualifiers are appropriate they will be added. The result
8480 will be allocated on the objfile_obstack, or NULL if the DIE does
8481 not have a name. NAME may either be from a previous call to
8482 dwarf2_name or NULL.
8484 The output string will be canonicalized (if C++/Java). */
8487 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8489 return dwarf2_compute_name (name
, die
, cu
, 0);
8492 /* Construct a physname for the given DIE in CU. NAME may either be
8493 from a previous call to dwarf2_name or NULL. The result will be
8494 allocated on the objfile_objstack or NULL if the DIE does not have a
8497 The output string will be canonicalized (if C++/Java). */
8500 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8502 struct objfile
*objfile
= cu
->objfile
;
8503 struct attribute
*attr
;
8504 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
8505 struct cleanup
*back_to
;
8508 /* In this case dwarf2_compute_name is just a shortcut not building anything
8510 if (!die_needs_namespace (die
, cu
))
8511 return dwarf2_compute_name (name
, die
, cu
, 1);
8513 back_to
= make_cleanup (null_cleanup
, NULL
);
8515 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8517 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8519 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8521 if (attr
&& DW_STRING (attr
))
8525 mangled
= DW_STRING (attr
);
8527 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8528 type. It is easier for GDB users to search for such functions as
8529 `name(params)' than `long name(params)'. In such case the minimal
8530 symbol names do not match the full symbol names but for template
8531 functions there is never a need to look up their definition from their
8532 declaration so the only disadvantage remains the minimal symbol
8533 variant `long name(params)' does not have the proper inferior type.
8536 if (cu
->language
== language_go
)
8538 /* This is a lie, but we already lie to the caller new_symbol_full.
8539 new_symbol_full assumes we return the mangled name.
8540 This just undoes that lie until things are cleaned up. */
8545 demangled
= gdb_demangle (mangled
,
8546 (DMGL_PARAMS
| DMGL_ANSI
8547 | (cu
->language
== language_java
8548 ? DMGL_JAVA
| DMGL_RET_POSTFIX
8553 make_cleanup (xfree
, demangled
);
8563 if (canon
== NULL
|| check_physname
)
8565 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
8567 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
8569 /* It may not mean a bug in GDB. The compiler could also
8570 compute DW_AT_linkage_name incorrectly. But in such case
8571 GDB would need to be bug-to-bug compatible. */
8573 complaint (&symfile_complaints
,
8574 _("Computed physname <%s> does not match demangled <%s> "
8575 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8576 physname
, canon
, mangled
, die
->offset
.sect_off
,
8577 objfile_name (objfile
));
8579 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8580 is available here - over computed PHYSNAME. It is safer
8581 against both buggy GDB and buggy compilers. */
8595 retval
= obstack_copy0 (&objfile
->objfile_obstack
, retval
, strlen (retval
));
8597 do_cleanups (back_to
);
8601 /* Inspect DIE in CU for a namespace alias. If one exists, record
8602 a new symbol for it.
8604 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8607 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
8609 struct attribute
*attr
;
8611 /* If the die does not have a name, this is not a namespace
8613 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8617 struct die_info
*d
= die
;
8618 struct dwarf2_cu
*imported_cu
= cu
;
8620 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8621 keep inspecting DIEs until we hit the underlying import. */
8622 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8623 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
8625 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
8629 d
= follow_die_ref (d
, attr
, &imported_cu
);
8630 if (d
->tag
!= DW_TAG_imported_declaration
)
8634 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
8636 complaint (&symfile_complaints
,
8637 _("DIE at 0x%x has too many recursively imported "
8638 "declarations"), d
->offset
.sect_off
);
8645 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
8647 type
= get_die_type_at_offset (offset
, cu
->per_cu
);
8648 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
8650 /* This declaration is a global namespace alias. Add
8651 a symbol for it whose type is the aliased namespace. */
8652 new_symbol (die
, type
, cu
);
8661 /* Read the import statement specified by the given die and record it. */
8664 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
8666 struct objfile
*objfile
= cu
->objfile
;
8667 struct attribute
*import_attr
;
8668 struct die_info
*imported_die
, *child_die
;
8669 struct dwarf2_cu
*imported_cu
;
8670 const char *imported_name
;
8671 const char *imported_name_prefix
;
8672 const char *canonical_name
;
8673 const char *import_alias
;
8674 const char *imported_declaration
= NULL
;
8675 const char *import_prefix
;
8676 VEC (const_char_ptr
) *excludes
= NULL
;
8677 struct cleanup
*cleanups
;
8679 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8680 if (import_attr
== NULL
)
8682 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8683 dwarf_tag_name (die
->tag
));
8688 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
8689 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8690 if (imported_name
== NULL
)
8692 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8694 The import in the following code:
8708 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8709 <52> DW_AT_decl_file : 1
8710 <53> DW_AT_decl_line : 6
8711 <54> DW_AT_import : <0x75>
8712 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8714 <5b> DW_AT_decl_file : 1
8715 <5c> DW_AT_decl_line : 2
8716 <5d> DW_AT_type : <0x6e>
8718 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8719 <76> DW_AT_byte_size : 4
8720 <77> DW_AT_encoding : 5 (signed)
8722 imports the wrong die ( 0x75 instead of 0x58 ).
8723 This case will be ignored until the gcc bug is fixed. */
8727 /* Figure out the local name after import. */
8728 import_alias
= dwarf2_name (die
, cu
);
8730 /* Figure out where the statement is being imported to. */
8731 import_prefix
= determine_prefix (die
, cu
);
8733 /* Figure out what the scope of the imported die is and prepend it
8734 to the name of the imported die. */
8735 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
8737 if (imported_die
->tag
!= DW_TAG_namespace
8738 && imported_die
->tag
!= DW_TAG_module
)
8740 imported_declaration
= imported_name
;
8741 canonical_name
= imported_name_prefix
;
8743 else if (strlen (imported_name_prefix
) > 0)
8744 canonical_name
= obconcat (&objfile
->objfile_obstack
,
8745 imported_name_prefix
, "::", imported_name
,
8748 canonical_name
= imported_name
;
8750 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
8752 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
8753 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
8754 child_die
= sibling_die (child_die
))
8756 /* DWARF-4: A Fortran use statement with a “rename list” may be
8757 represented by an imported module entry with an import attribute
8758 referring to the module and owned entries corresponding to those
8759 entities that are renamed as part of being imported. */
8761 if (child_die
->tag
!= DW_TAG_imported_declaration
)
8763 complaint (&symfile_complaints
,
8764 _("child DW_TAG_imported_declaration expected "
8765 "- DIE at 0x%x [in module %s]"),
8766 child_die
->offset
.sect_off
, objfile_name (objfile
));
8770 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
8771 if (import_attr
== NULL
)
8773 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8774 dwarf_tag_name (child_die
->tag
));
8779 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
8781 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8782 if (imported_name
== NULL
)
8784 complaint (&symfile_complaints
,
8785 _("child DW_TAG_imported_declaration has unknown "
8786 "imported name - DIE at 0x%x [in module %s]"),
8787 child_die
->offset
.sect_off
, objfile_name (objfile
));
8791 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
8793 process_die (child_die
, cu
);
8796 cp_add_using_directive (import_prefix
,
8799 imported_declaration
,
8802 &objfile
->objfile_obstack
);
8804 do_cleanups (cleanups
);
8807 /* Cleanup function for handle_DW_AT_stmt_list. */
8810 free_cu_line_header (void *arg
)
8812 struct dwarf2_cu
*cu
= arg
;
8814 free_line_header (cu
->line_header
);
8815 cu
->line_header
= NULL
;
8818 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
8819 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
8820 this, it was first present in GCC release 4.3.0. */
8823 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
8825 if (!cu
->checked_producer
)
8826 check_producer (cu
);
8828 return cu
->producer_is_gcc_lt_4_3
;
8832 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
8833 const char **name
, const char **comp_dir
)
8835 struct attribute
*attr
;
8840 /* Find the filename. Do not use dwarf2_name here, since the filename
8841 is not a source language identifier. */
8842 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8845 *name
= DW_STRING (attr
);
8848 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
8850 *comp_dir
= DW_STRING (attr
);
8851 else if (producer_is_gcc_lt_4_3 (cu
) && *name
!= NULL
8852 && IS_ABSOLUTE_PATH (*name
))
8854 char *d
= ldirname (*name
);
8858 make_cleanup (xfree
, d
);
8860 if (*comp_dir
!= NULL
)
8862 /* Irix 6.2 native cc prepends <machine>.: to the compilation
8863 directory, get rid of it. */
8864 char *cp
= strchr (*comp_dir
, ':');
8866 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
8871 *name
= "<unknown>";
8874 /* Handle DW_AT_stmt_list for a compilation unit.
8875 DIE is the DW_TAG_compile_unit die for CU.
8876 COMP_DIR is the compilation directory.
8877 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
8880 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
8881 const char *comp_dir
) /* ARI: editCase function */
8883 struct attribute
*attr
;
8885 gdb_assert (! cu
->per_cu
->is_debug_types
);
8887 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
8890 unsigned int line_offset
= DW_UNSND (attr
);
8891 struct line_header
*line_header
8892 = dwarf_decode_line_header (line_offset
, cu
);
8896 cu
->line_header
= line_header
;
8897 make_cleanup (free_cu_line_header
, cu
);
8898 dwarf_decode_lines (line_header
, comp_dir
, cu
, NULL
, 1);
8903 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
8906 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
8908 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8909 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
8910 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
8911 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
8912 struct attribute
*attr
;
8913 const char *name
= NULL
;
8914 const char *comp_dir
= NULL
;
8915 struct die_info
*child_die
;
8916 bfd
*abfd
= objfile
->obfd
;
8919 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8921 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
8923 /* If we didn't find a lowpc, set it to highpc to avoid complaints
8924 from finish_block. */
8925 if (lowpc
== ((CORE_ADDR
) -1))
8930 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
8932 prepare_one_comp_unit (cu
, die
, cu
->language
);
8934 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
8935 standardised yet. As a workaround for the language detection we fall
8936 back to the DW_AT_producer string. */
8937 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
8938 cu
->language
= language_opencl
;
8940 /* Similar hack for Go. */
8941 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
8942 set_cu_language (DW_LANG_Go
, cu
);
8944 dwarf2_start_symtab (cu
, name
, comp_dir
, lowpc
);
8946 /* Decode line number information if present. We do this before
8947 processing child DIEs, so that the line header table is available
8948 for DW_AT_decl_file. */
8949 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
8951 /* Process all dies in compilation unit. */
8952 if (die
->child
!= NULL
)
8954 child_die
= die
->child
;
8955 while (child_die
&& child_die
->tag
)
8957 process_die (child_die
, cu
);
8958 child_die
= sibling_die (child_die
);
8962 /* Decode macro information, if present. Dwarf 2 macro information
8963 refers to information in the line number info statement program
8964 header, so we can only read it if we've read the header
8966 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
8967 if (attr
&& cu
->line_header
)
8969 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
8970 complaint (&symfile_complaints
,
8971 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
8973 dwarf_decode_macros (cu
, DW_UNSND (attr
), comp_dir
, 1);
8977 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
8978 if (attr
&& cu
->line_header
)
8980 unsigned int macro_offset
= DW_UNSND (attr
);
8982 dwarf_decode_macros (cu
, macro_offset
, comp_dir
, 0);
8986 do_cleanups (back_to
);
8989 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
8990 Create the set of symtabs used by this TU, or if this TU is sharing
8991 symtabs with another TU and the symtabs have already been created
8992 then restore those symtabs in the line header.
8993 We don't need the pc/line-number mapping for type units. */
8996 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
8998 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8999 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
9000 struct type_unit_group
*tu_group
;
9002 struct line_header
*lh
;
9003 struct attribute
*attr
;
9004 unsigned int i
, line_offset
;
9005 struct signatured_type
*sig_type
;
9007 gdb_assert (per_cu
->is_debug_types
);
9008 sig_type
= (struct signatured_type
*) per_cu
;
9010 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9012 /* If we're using .gdb_index (includes -readnow) then
9013 per_cu->type_unit_group may not have been set up yet. */
9014 if (sig_type
->type_unit_group
== NULL
)
9015 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
9016 tu_group
= sig_type
->type_unit_group
;
9018 /* If we've already processed this stmt_list there's no real need to
9019 do it again, we could fake it and just recreate the part we need
9020 (file name,index -> symtab mapping). If data shows this optimization
9021 is useful we can do it then. */
9022 first_time
= tu_group
->primary_symtab
== NULL
;
9024 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9029 line_offset
= DW_UNSND (attr
);
9030 lh
= dwarf_decode_line_header (line_offset
, cu
);
9035 dwarf2_start_symtab (cu
, "", NULL
, 0);
9038 gdb_assert (tu_group
->symtabs
== NULL
);
9041 /* Note: The primary symtab will get allocated at the end. */
9045 cu
->line_header
= lh
;
9046 make_cleanup (free_cu_line_header
, cu
);
9050 dwarf2_start_symtab (cu
, "", NULL
, 0);
9052 tu_group
->num_symtabs
= lh
->num_file_names
;
9053 tu_group
->symtabs
= XNEWVEC (struct symtab
*, lh
->num_file_names
);
9055 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9057 const char *dir
= NULL
;
9058 struct file_entry
*fe
= &lh
->file_names
[i
];
9061 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9062 dwarf2_start_subfile (fe
->name
, dir
, NULL
);
9064 /* Note: We don't have to watch for the main subfile here, type units
9065 don't have DW_AT_name. */
9067 if (current_subfile
->symtab
== NULL
)
9069 /* NOTE: start_subfile will recognize when it's been passed
9070 a file it has already seen. So we can't assume there's a
9071 simple mapping from lh->file_names to subfiles,
9072 lh->file_names may contain dups. */
9073 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
9077 fe
->symtab
= current_subfile
->symtab
;
9078 tu_group
->symtabs
[i
] = fe
->symtab
;
9085 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9087 struct file_entry
*fe
= &lh
->file_names
[i
];
9089 fe
->symtab
= tu_group
->symtabs
[i
];
9093 /* The main symtab is allocated last. Type units don't have DW_AT_name
9094 so they don't have a "real" (so to speak) symtab anyway.
9095 There is later code that will assign the main symtab to all symbols
9096 that don't have one. We need to handle the case of a symbol with a
9097 missing symtab (DW_AT_decl_file) anyway. */
9100 /* Process DW_TAG_type_unit.
9101 For TUs we want to skip the first top level sibling if it's not the
9102 actual type being defined by this TU. In this case the first top
9103 level sibling is there to provide context only. */
9106 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9108 struct die_info
*child_die
;
9110 prepare_one_comp_unit (cu
, die
, language_minimal
);
9112 /* Initialize (or reinitialize) the machinery for building symtabs.
9113 We do this before processing child DIEs, so that the line header table
9114 is available for DW_AT_decl_file. */
9115 setup_type_unit_groups (die
, cu
);
9117 if (die
->child
!= NULL
)
9119 child_die
= die
->child
;
9120 while (child_die
&& child_die
->tag
)
9122 process_die (child_die
, cu
);
9123 child_die
= sibling_die (child_die
);
9130 http://gcc.gnu.org/wiki/DebugFission
9131 http://gcc.gnu.org/wiki/DebugFissionDWP
9133 To simplify handling of both DWO files ("object" files with the DWARF info)
9134 and DWP files (a file with the DWOs packaged up into one file), we treat
9135 DWP files as having a collection of virtual DWO files. */
9138 hash_dwo_file (const void *item
)
9140 const struct dwo_file
*dwo_file
= item
;
9143 hash
= htab_hash_string (dwo_file
->dwo_name
);
9144 if (dwo_file
->comp_dir
!= NULL
)
9145 hash
+= htab_hash_string (dwo_file
->comp_dir
);
9150 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
9152 const struct dwo_file
*lhs
= item_lhs
;
9153 const struct dwo_file
*rhs
= item_rhs
;
9155 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
9157 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
9158 return lhs
->comp_dir
== rhs
->comp_dir
;
9159 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
9162 /* Allocate a hash table for DWO files. */
9165 allocate_dwo_file_hash_table (void)
9167 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9169 return htab_create_alloc_ex (41,
9173 &objfile
->objfile_obstack
,
9174 hashtab_obstack_allocate
,
9175 dummy_obstack_deallocate
);
9178 /* Lookup DWO file DWO_NAME. */
9181 lookup_dwo_file_slot (const char *dwo_name
, const char *comp_dir
)
9183 struct dwo_file find_entry
;
9186 if (dwarf2_per_objfile
->dwo_files
== NULL
)
9187 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
9189 memset (&find_entry
, 0, sizeof (find_entry
));
9190 find_entry
.dwo_name
= dwo_name
;
9191 find_entry
.comp_dir
= comp_dir
;
9192 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
9198 hash_dwo_unit (const void *item
)
9200 const struct dwo_unit
*dwo_unit
= item
;
9202 /* This drops the top 32 bits of the id, but is ok for a hash. */
9203 return dwo_unit
->signature
;
9207 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
9209 const struct dwo_unit
*lhs
= item_lhs
;
9210 const struct dwo_unit
*rhs
= item_rhs
;
9212 /* The signature is assumed to be unique within the DWO file.
9213 So while object file CU dwo_id's always have the value zero,
9214 that's OK, assuming each object file DWO file has only one CU,
9215 and that's the rule for now. */
9216 return lhs
->signature
== rhs
->signature
;
9219 /* Allocate a hash table for DWO CUs,TUs.
9220 There is one of these tables for each of CUs,TUs for each DWO file. */
9223 allocate_dwo_unit_table (struct objfile
*objfile
)
9225 /* Start out with a pretty small number.
9226 Generally DWO files contain only one CU and maybe some TUs. */
9227 return htab_create_alloc_ex (3,
9231 &objfile
->objfile_obstack
,
9232 hashtab_obstack_allocate
,
9233 dummy_obstack_deallocate
);
9236 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9238 struct create_dwo_cu_data
9240 struct dwo_file
*dwo_file
;
9241 struct dwo_unit dwo_unit
;
9244 /* die_reader_func for create_dwo_cu. */
9247 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
9248 const gdb_byte
*info_ptr
,
9249 struct die_info
*comp_unit_die
,
9253 struct dwarf2_cu
*cu
= reader
->cu
;
9254 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9255 sect_offset offset
= cu
->per_cu
->offset
;
9256 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
9257 struct create_dwo_cu_data
*data
= datap
;
9258 struct dwo_file
*dwo_file
= data
->dwo_file
;
9259 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
9260 struct attribute
*attr
;
9262 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
9265 complaint (&symfile_complaints
,
9266 _("Dwarf Error: debug entry at offset 0x%x is missing"
9267 " its dwo_id [in module %s]"),
9268 offset
.sect_off
, dwo_file
->dwo_name
);
9272 dwo_unit
->dwo_file
= dwo_file
;
9273 dwo_unit
->signature
= DW_UNSND (attr
);
9274 dwo_unit
->section
= section
;
9275 dwo_unit
->offset
= offset
;
9276 dwo_unit
->length
= cu
->per_cu
->length
;
9278 if (dwarf2_read_debug
)
9279 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id %s\n",
9280 offset
.sect_off
, hex_string (dwo_unit
->signature
));
9283 /* Create the dwo_unit for the lone CU in DWO_FILE.
9284 Note: This function processes DWO files only, not DWP files. */
9286 static struct dwo_unit
*
9287 create_dwo_cu (struct dwo_file
*dwo_file
)
9289 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9290 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
9293 const gdb_byte
*info_ptr
, *end_ptr
;
9294 struct create_dwo_cu_data create_dwo_cu_data
;
9295 struct dwo_unit
*dwo_unit
;
9297 dwarf2_read_section (objfile
, section
);
9298 info_ptr
= section
->buffer
;
9300 if (info_ptr
== NULL
)
9303 /* We can't set abfd until now because the section may be empty or
9304 not present, in which case section->asection will be NULL. */
9305 abfd
= get_section_bfd_owner (section
);
9307 if (dwarf2_read_debug
)
9309 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
9310 get_section_name (section
),
9311 get_section_file_name (section
));
9314 create_dwo_cu_data
.dwo_file
= dwo_file
;
9317 end_ptr
= info_ptr
+ section
->size
;
9318 while (info_ptr
< end_ptr
)
9320 struct dwarf2_per_cu_data per_cu
;
9322 memset (&create_dwo_cu_data
.dwo_unit
, 0,
9323 sizeof (create_dwo_cu_data
.dwo_unit
));
9324 memset (&per_cu
, 0, sizeof (per_cu
));
9325 per_cu
.objfile
= objfile
;
9326 per_cu
.is_debug_types
= 0;
9327 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
9328 per_cu
.section
= section
;
9330 init_cutu_and_read_dies_no_follow (&per_cu
, dwo_file
,
9331 create_dwo_cu_reader
,
9332 &create_dwo_cu_data
);
9334 if (create_dwo_cu_data
.dwo_unit
.dwo_file
!= NULL
)
9336 /* If we've already found one, complain. We only support one
9337 because having more than one requires hacking the dwo_name of
9338 each to match, which is highly unlikely to happen. */
9339 if (dwo_unit
!= NULL
)
9341 complaint (&symfile_complaints
,
9342 _("Multiple CUs in DWO file %s [in module %s]"),
9343 dwo_file
->dwo_name
, objfile_name (objfile
));
9347 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
9348 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
9351 info_ptr
+= per_cu
.length
;
9357 /* DWP file .debug_{cu,tu}_index section format:
9358 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9362 Both index sections have the same format, and serve to map a 64-bit
9363 signature to a set of section numbers. Each section begins with a header,
9364 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9365 indexes, and a pool of 32-bit section numbers. The index sections will be
9366 aligned at 8-byte boundaries in the file.
9368 The index section header consists of:
9370 V, 32 bit version number
9372 N, 32 bit number of compilation units or type units in the index
9373 M, 32 bit number of slots in the hash table
9375 Numbers are recorded using the byte order of the application binary.
9377 The hash table begins at offset 16 in the section, and consists of an array
9378 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9379 order of the application binary). Unused slots in the hash table are 0.
9380 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9382 The parallel table begins immediately after the hash table
9383 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9384 array of 32-bit indexes (using the byte order of the application binary),
9385 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9386 table contains a 32-bit index into the pool of section numbers. For unused
9387 hash table slots, the corresponding entry in the parallel table will be 0.
9389 The pool of section numbers begins immediately following the hash table
9390 (at offset 16 + 12 * M from the beginning of the section). The pool of
9391 section numbers consists of an array of 32-bit words (using the byte order
9392 of the application binary). Each item in the array is indexed starting
9393 from 0. The hash table entry provides the index of the first section
9394 number in the set. Additional section numbers in the set follow, and the
9395 set is terminated by a 0 entry (section number 0 is not used in ELF).
9397 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9398 section must be the first entry in the set, and the .debug_abbrev.dwo must
9399 be the second entry. Other members of the set may follow in any order.
9405 DWP Version 2 combines all the .debug_info, etc. sections into one,
9406 and the entries in the index tables are now offsets into these sections.
9407 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9410 Index Section Contents:
9412 Hash Table of Signatures dwp_hash_table.hash_table
9413 Parallel Table of Indices dwp_hash_table.unit_table
9414 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9415 Table of Section Sizes dwp_hash_table.v2.sizes
9417 The index section header consists of:
9419 V, 32 bit version number
9420 L, 32 bit number of columns in the table of section offsets
9421 N, 32 bit number of compilation units or type units in the index
9422 M, 32 bit number of slots in the hash table
9424 Numbers are recorded using the byte order of the application binary.
9426 The hash table has the same format as version 1.
9427 The parallel table of indices has the same format as version 1,
9428 except that the entries are origin-1 indices into the table of sections
9429 offsets and the table of section sizes.
9431 The table of offsets begins immediately following the parallel table
9432 (at offset 16 + 12 * M from the beginning of the section). The table is
9433 a two-dimensional array of 32-bit words (using the byte order of the
9434 application binary), with L columns and N+1 rows, in row-major order.
9435 Each row in the array is indexed starting from 0. The first row provides
9436 a key to the remaining rows: each column in this row provides an identifier
9437 for a debug section, and the offsets in the same column of subsequent rows
9438 refer to that section. The section identifiers are:
9440 DW_SECT_INFO 1 .debug_info.dwo
9441 DW_SECT_TYPES 2 .debug_types.dwo
9442 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9443 DW_SECT_LINE 4 .debug_line.dwo
9444 DW_SECT_LOC 5 .debug_loc.dwo
9445 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9446 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9447 DW_SECT_MACRO 8 .debug_macro.dwo
9449 The offsets provided by the CU and TU index sections are the base offsets
9450 for the contributions made by each CU or TU to the corresponding section
9451 in the package file. Each CU and TU header contains an abbrev_offset
9452 field, used to find the abbreviations table for that CU or TU within the
9453 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9454 be interpreted as relative to the base offset given in the index section.
9455 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9456 should be interpreted as relative to the base offset for .debug_line.dwo,
9457 and offsets into other debug sections obtained from DWARF attributes should
9458 also be interpreted as relative to the corresponding base offset.
9460 The table of sizes begins immediately following the table of offsets.
9461 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9462 with L columns and N rows, in row-major order. Each row in the array is
9463 indexed starting from 1 (row 0 is shared by the two tables).
9467 Hash table lookup is handled the same in version 1 and 2:
9469 We assume that N and M will not exceed 2^32 - 1.
9470 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9472 Given a 64-bit compilation unit signature or a type signature S, an entry
9473 in the hash table is located as follows:
9475 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9476 the low-order k bits all set to 1.
9478 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9480 3) If the hash table entry at index H matches the signature, use that
9481 entry. If the hash table entry at index H is unused (all zeroes),
9482 terminate the search: the signature is not present in the table.
9484 4) Let H = (H + H') modulo M. Repeat at Step 3.
9486 Because M > N and H' and M are relatively prime, the search is guaranteed
9487 to stop at an unused slot or find the match. */
9489 /* Create a hash table to map DWO IDs to their CU/TU entry in
9490 .debug_{info,types}.dwo in DWP_FILE.
9491 Returns NULL if there isn't one.
9492 Note: This function processes DWP files only, not DWO files. */
9494 static struct dwp_hash_table
*
9495 create_dwp_hash_table (struct dwp_file
*dwp_file
, int is_debug_types
)
9497 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9498 bfd
*dbfd
= dwp_file
->dbfd
;
9499 const gdb_byte
*index_ptr
, *index_end
;
9500 struct dwarf2_section_info
*index
;
9501 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
9502 struct dwp_hash_table
*htab
;
9505 index
= &dwp_file
->sections
.tu_index
;
9507 index
= &dwp_file
->sections
.cu_index
;
9509 if (dwarf2_section_empty_p (index
))
9511 dwarf2_read_section (objfile
, index
);
9513 index_ptr
= index
->buffer
;
9514 index_end
= index_ptr
+ index
->size
;
9516 version
= read_4_bytes (dbfd
, index_ptr
);
9519 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
9523 nr_units
= read_4_bytes (dbfd
, index_ptr
);
9525 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
9528 if (version
!= 1 && version
!= 2)
9530 error (_("Dwarf Error: unsupported DWP file version (%s)"
9532 pulongest (version
), dwp_file
->name
);
9534 if (nr_slots
!= (nr_slots
& -nr_slots
))
9536 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9537 " is not power of 2 [in module %s]"),
9538 pulongest (nr_slots
), dwp_file
->name
);
9541 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
9542 htab
->version
= version
;
9543 htab
->nr_columns
= nr_columns
;
9544 htab
->nr_units
= nr_units
;
9545 htab
->nr_slots
= nr_slots
;
9546 htab
->hash_table
= index_ptr
;
9547 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
9549 /* Exit early if the table is empty. */
9550 if (nr_slots
== 0 || nr_units
== 0
9551 || (version
== 2 && nr_columns
== 0))
9553 /* All must be zero. */
9554 if (nr_slots
!= 0 || nr_units
!= 0
9555 || (version
== 2 && nr_columns
!= 0))
9557 complaint (&symfile_complaints
,
9558 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9559 " all zero [in modules %s]"),
9567 htab
->section_pool
.v1
.indices
=
9568 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9569 /* It's harder to decide whether the section is too small in v1.
9570 V1 is deprecated anyway so we punt. */
9574 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9575 int *ids
= htab
->section_pool
.v2
.section_ids
;
9576 /* Reverse map for error checking. */
9577 int ids_seen
[DW_SECT_MAX
+ 1];
9582 error (_("Dwarf Error: bad DWP hash table, too few columns"
9583 " in section table [in module %s]"),
9586 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
9588 error (_("Dwarf Error: bad DWP hash table, too many columns"
9589 " in section table [in module %s]"),
9592 memset (ids
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9593 memset (ids_seen
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9594 for (i
= 0; i
< nr_columns
; ++i
)
9596 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
9598 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
9600 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9601 " in section table [in module %s]"),
9602 id
, dwp_file
->name
);
9604 if (ids_seen
[id
] != -1)
9606 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9607 " id %d in section table [in module %s]"),
9608 id
, dwp_file
->name
);
9613 /* Must have exactly one info or types section. */
9614 if (((ids_seen
[DW_SECT_INFO
] != -1)
9615 + (ids_seen
[DW_SECT_TYPES
] != -1))
9618 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9619 " DWO info/types section [in module %s]"),
9622 /* Must have an abbrev section. */
9623 if (ids_seen
[DW_SECT_ABBREV
] == -1)
9625 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9626 " section [in module %s]"),
9629 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
9630 htab
->section_pool
.v2
.sizes
=
9631 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
9632 * nr_units
* nr_columns
);
9633 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
9634 * nr_units
* nr_columns
))
9637 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9646 /* Update SECTIONS with the data from SECTP.
9648 This function is like the other "locate" section routines that are
9649 passed to bfd_map_over_sections, but in this context the sections to
9650 read comes from the DWP V1 hash table, not the full ELF section table.
9652 The result is non-zero for success, or zero if an error was found. */
9655 locate_v1_virtual_dwo_sections (asection
*sectp
,
9656 struct virtual_v1_dwo_sections
*sections
)
9658 const struct dwop_section_names
*names
= &dwop_section_names
;
9660 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
9662 /* There can be only one. */
9663 if (sections
->abbrev
.s
.asection
!= NULL
)
9665 sections
->abbrev
.s
.asection
= sectp
;
9666 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
9668 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
9669 || section_is_p (sectp
->name
, &names
->types_dwo
))
9671 /* There can be only one. */
9672 if (sections
->info_or_types
.s
.asection
!= NULL
)
9674 sections
->info_or_types
.s
.asection
= sectp
;
9675 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
9677 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
9679 /* There can be only one. */
9680 if (sections
->line
.s
.asection
!= NULL
)
9682 sections
->line
.s
.asection
= sectp
;
9683 sections
->line
.size
= bfd_get_section_size (sectp
);
9685 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
9687 /* There can be only one. */
9688 if (sections
->loc
.s
.asection
!= NULL
)
9690 sections
->loc
.s
.asection
= sectp
;
9691 sections
->loc
.size
= bfd_get_section_size (sectp
);
9693 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
9695 /* There can be only one. */
9696 if (sections
->macinfo
.s
.asection
!= NULL
)
9698 sections
->macinfo
.s
.asection
= sectp
;
9699 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
9701 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
9703 /* There can be only one. */
9704 if (sections
->macro
.s
.asection
!= NULL
)
9706 sections
->macro
.s
.asection
= sectp
;
9707 sections
->macro
.size
= bfd_get_section_size (sectp
);
9709 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
9711 /* There can be only one. */
9712 if (sections
->str_offsets
.s
.asection
!= NULL
)
9714 sections
->str_offsets
.s
.asection
= sectp
;
9715 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
9719 /* No other kind of section is valid. */
9726 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9727 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9728 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9729 This is for DWP version 1 files. */
9731 static struct dwo_unit
*
9732 create_dwo_unit_in_dwp_v1 (struct dwp_file
*dwp_file
,
9733 uint32_t unit_index
,
9734 const char *comp_dir
,
9735 ULONGEST signature
, int is_debug_types
)
9737 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9738 const struct dwp_hash_table
*dwp_htab
=
9739 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
9740 bfd
*dbfd
= dwp_file
->dbfd
;
9741 const char *kind
= is_debug_types
? "TU" : "CU";
9742 struct dwo_file
*dwo_file
;
9743 struct dwo_unit
*dwo_unit
;
9744 struct virtual_v1_dwo_sections sections
;
9745 void **dwo_file_slot
;
9746 char *virtual_dwo_name
;
9747 struct dwarf2_section_info
*cutu
;
9748 struct cleanup
*cleanups
;
9751 gdb_assert (dwp_file
->version
== 1);
9753 if (dwarf2_read_debug
)
9755 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
9757 pulongest (unit_index
), hex_string (signature
),
9761 /* Fetch the sections of this DWO unit.
9762 Put a limit on the number of sections we look for so that bad data
9763 doesn't cause us to loop forever. */
9765 #define MAX_NR_V1_DWO_SECTIONS \
9766 (1 /* .debug_info or .debug_types */ \
9767 + 1 /* .debug_abbrev */ \
9768 + 1 /* .debug_line */ \
9769 + 1 /* .debug_loc */ \
9770 + 1 /* .debug_str_offsets */ \
9771 + 1 /* .debug_macro or .debug_macinfo */ \
9772 + 1 /* trailing zero */)
9774 memset (§ions
, 0, sizeof (sections
));
9775 cleanups
= make_cleanup (null_cleanup
, 0);
9777 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
9780 uint32_t section_nr
=
9782 dwp_htab
->section_pool
.v1
.indices
9783 + (unit_index
+ i
) * sizeof (uint32_t));
9785 if (section_nr
== 0)
9787 if (section_nr
>= dwp_file
->num_sections
)
9789 error (_("Dwarf Error: bad DWP hash table, section number too large"
9794 sectp
= dwp_file
->elf_sections
[section_nr
];
9795 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
9797 error (_("Dwarf Error: bad DWP hash table, invalid section found"
9804 || dwarf2_section_empty_p (§ions
.info_or_types
)
9805 || dwarf2_section_empty_p (§ions
.abbrev
))
9807 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
9811 if (i
== MAX_NR_V1_DWO_SECTIONS
)
9813 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
9818 /* It's easier for the rest of the code if we fake a struct dwo_file and
9819 have dwo_unit "live" in that. At least for now.
9821 The DWP file can be made up of a random collection of CUs and TUs.
9822 However, for each CU + set of TUs that came from the same original DWO
9823 file, we can combine them back into a virtual DWO file to save space
9824 (fewer struct dwo_file objects to allocate). Remember that for really
9825 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
9828 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
9829 get_section_id (§ions
.abbrev
),
9830 get_section_id (§ions
.line
),
9831 get_section_id (§ions
.loc
),
9832 get_section_id (§ions
.str_offsets
));
9833 make_cleanup (xfree
, virtual_dwo_name
);
9834 /* Can we use an existing virtual DWO file? */
9835 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
9836 /* Create one if necessary. */
9837 if (*dwo_file_slot
== NULL
)
9839 if (dwarf2_read_debug
)
9841 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
9844 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
9845 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
9847 strlen (virtual_dwo_name
));
9848 dwo_file
->comp_dir
= comp_dir
;
9849 dwo_file
->sections
.abbrev
= sections
.abbrev
;
9850 dwo_file
->sections
.line
= sections
.line
;
9851 dwo_file
->sections
.loc
= sections
.loc
;
9852 dwo_file
->sections
.macinfo
= sections
.macinfo
;
9853 dwo_file
->sections
.macro
= sections
.macro
;
9854 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
9855 /* The "str" section is global to the entire DWP file. */
9856 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
9857 /* The info or types section is assigned below to dwo_unit,
9858 there's no need to record it in dwo_file.
9859 Also, we can't simply record type sections in dwo_file because
9860 we record a pointer into the vector in dwo_unit. As we collect more
9861 types we'll grow the vector and eventually have to reallocate space
9862 for it, invalidating all copies of pointers into the previous
9864 *dwo_file_slot
= dwo_file
;
9868 if (dwarf2_read_debug
)
9870 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
9873 dwo_file
= *dwo_file_slot
;
9875 do_cleanups (cleanups
);
9877 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
9878 dwo_unit
->dwo_file
= dwo_file
;
9879 dwo_unit
->signature
= signature
;
9880 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
9881 sizeof (struct dwarf2_section_info
));
9882 *dwo_unit
->section
= sections
.info_or_types
;
9883 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
9888 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
9889 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
9890 piece within that section used by a TU/CU, return a virtual section
9891 of just that piece. */
9893 static struct dwarf2_section_info
9894 create_dwp_v2_section (struct dwarf2_section_info
*section
,
9895 bfd_size_type offset
, bfd_size_type size
)
9897 struct dwarf2_section_info result
;
9900 gdb_assert (section
!= NULL
);
9901 gdb_assert (!section
->is_virtual
);
9903 memset (&result
, 0, sizeof (result
));
9904 result
.s
.containing_section
= section
;
9905 result
.is_virtual
= 1;
9910 sectp
= get_section_bfd_section (section
);
9912 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
9913 bounds of the real section. This is a pretty-rare event, so just
9914 flag an error (easier) instead of a warning and trying to cope. */
9916 || offset
+ size
> bfd_get_section_size (sectp
))
9918 bfd
*abfd
= sectp
->owner
;
9920 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
9921 " in section %s [in module %s]"),
9922 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
9923 objfile_name (dwarf2_per_objfile
->objfile
));
9926 result
.virtual_offset
= offset
;
9931 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9932 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9933 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9934 This is for DWP version 2 files. */
9936 static struct dwo_unit
*
9937 create_dwo_unit_in_dwp_v2 (struct dwp_file
*dwp_file
,
9938 uint32_t unit_index
,
9939 const char *comp_dir
,
9940 ULONGEST signature
, int is_debug_types
)
9942 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9943 const struct dwp_hash_table
*dwp_htab
=
9944 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
9945 bfd
*dbfd
= dwp_file
->dbfd
;
9946 const char *kind
= is_debug_types
? "TU" : "CU";
9947 struct dwo_file
*dwo_file
;
9948 struct dwo_unit
*dwo_unit
;
9949 struct virtual_v2_dwo_sections sections
;
9950 void **dwo_file_slot
;
9951 char *virtual_dwo_name
;
9952 struct dwarf2_section_info
*cutu
;
9953 struct cleanup
*cleanups
;
9956 gdb_assert (dwp_file
->version
== 2);
9958 if (dwarf2_read_debug
)
9960 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
9962 pulongest (unit_index
), hex_string (signature
),
9966 /* Fetch the section offsets of this DWO unit. */
9968 memset (§ions
, 0, sizeof (sections
));
9969 cleanups
= make_cleanup (null_cleanup
, 0);
9971 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
9973 uint32_t offset
= read_4_bytes (dbfd
,
9974 dwp_htab
->section_pool
.v2
.offsets
9975 + (((unit_index
- 1) * dwp_htab
->nr_columns
9977 * sizeof (uint32_t)));
9978 uint32_t size
= read_4_bytes (dbfd
,
9979 dwp_htab
->section_pool
.v2
.sizes
9980 + (((unit_index
- 1) * dwp_htab
->nr_columns
9982 * sizeof (uint32_t)));
9984 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
9988 sections
.info_or_types_offset
= offset
;
9989 sections
.info_or_types_size
= size
;
9991 case DW_SECT_ABBREV
:
9992 sections
.abbrev_offset
= offset
;
9993 sections
.abbrev_size
= size
;
9996 sections
.line_offset
= offset
;
9997 sections
.line_size
= size
;
10000 sections
.loc_offset
= offset
;
10001 sections
.loc_size
= size
;
10003 case DW_SECT_STR_OFFSETS
:
10004 sections
.str_offsets_offset
= offset
;
10005 sections
.str_offsets_size
= size
;
10007 case DW_SECT_MACINFO
:
10008 sections
.macinfo_offset
= offset
;
10009 sections
.macinfo_size
= size
;
10011 case DW_SECT_MACRO
:
10012 sections
.macro_offset
= offset
;
10013 sections
.macro_size
= size
;
10018 /* It's easier for the rest of the code if we fake a struct dwo_file and
10019 have dwo_unit "live" in that. At least for now.
10021 The DWP file can be made up of a random collection of CUs and TUs.
10022 However, for each CU + set of TUs that came from the same original DWO
10023 file, we can combine them back into a virtual DWO file to save space
10024 (fewer struct dwo_file objects to allocate). Remember that for really
10025 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10028 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10029 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
10030 (long) (sections
.line_size
? sections
.line_offset
: 0),
10031 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
10032 (long) (sections
.str_offsets_size
10033 ? sections
.str_offsets_offset
: 0));
10034 make_cleanup (xfree
, virtual_dwo_name
);
10035 /* Can we use an existing virtual DWO file? */
10036 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10037 /* Create one if necessary. */
10038 if (*dwo_file_slot
== NULL
)
10040 if (dwarf2_read_debug
)
10042 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10045 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10046 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
10048 strlen (virtual_dwo_name
));
10049 dwo_file
->comp_dir
= comp_dir
;
10050 dwo_file
->sections
.abbrev
=
10051 create_dwp_v2_section (&dwp_file
->sections
.abbrev
,
10052 sections
.abbrev_offset
, sections
.abbrev_size
);
10053 dwo_file
->sections
.line
=
10054 create_dwp_v2_section (&dwp_file
->sections
.line
,
10055 sections
.line_offset
, sections
.line_size
);
10056 dwo_file
->sections
.loc
=
10057 create_dwp_v2_section (&dwp_file
->sections
.loc
,
10058 sections
.loc_offset
, sections
.loc_size
);
10059 dwo_file
->sections
.macinfo
=
10060 create_dwp_v2_section (&dwp_file
->sections
.macinfo
,
10061 sections
.macinfo_offset
, sections
.macinfo_size
);
10062 dwo_file
->sections
.macro
=
10063 create_dwp_v2_section (&dwp_file
->sections
.macro
,
10064 sections
.macro_offset
, sections
.macro_size
);
10065 dwo_file
->sections
.str_offsets
=
10066 create_dwp_v2_section (&dwp_file
->sections
.str_offsets
,
10067 sections
.str_offsets_offset
,
10068 sections
.str_offsets_size
);
10069 /* The "str" section is global to the entire DWP file. */
10070 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10071 /* The info or types section is assigned below to dwo_unit,
10072 there's no need to record it in dwo_file.
10073 Also, we can't simply record type sections in dwo_file because
10074 we record a pointer into the vector in dwo_unit. As we collect more
10075 types we'll grow the vector and eventually have to reallocate space
10076 for it, invalidating all copies of pointers into the previous
10078 *dwo_file_slot
= dwo_file
;
10082 if (dwarf2_read_debug
)
10084 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10087 dwo_file
= *dwo_file_slot
;
10089 do_cleanups (cleanups
);
10091 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10092 dwo_unit
->dwo_file
= dwo_file
;
10093 dwo_unit
->signature
= signature
;
10094 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
10095 sizeof (struct dwarf2_section_info
));
10096 *dwo_unit
->section
= create_dwp_v2_section (is_debug_types
10097 ? &dwp_file
->sections
.types
10098 : &dwp_file
->sections
.info
,
10099 sections
.info_or_types_offset
,
10100 sections
.info_or_types_size
);
10101 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10106 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10107 Returns NULL if the signature isn't found. */
10109 static struct dwo_unit
*
10110 lookup_dwo_unit_in_dwp (struct dwp_file
*dwp_file
, const char *comp_dir
,
10111 ULONGEST signature
, int is_debug_types
)
10113 const struct dwp_hash_table
*dwp_htab
=
10114 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10115 bfd
*dbfd
= dwp_file
->dbfd
;
10116 uint32_t mask
= dwp_htab
->nr_slots
- 1;
10117 uint32_t hash
= signature
& mask
;
10118 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
10121 struct dwo_unit find_dwo_cu
, *dwo_cu
;
10123 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
10124 find_dwo_cu
.signature
= signature
;
10125 slot
= htab_find_slot (is_debug_types
10126 ? dwp_file
->loaded_tus
10127 : dwp_file
->loaded_cus
,
10128 &find_dwo_cu
, INSERT
);
10133 /* Use a for loop so that we don't loop forever on bad debug info. */
10134 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
10136 ULONGEST signature_in_table
;
10138 signature_in_table
=
10139 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
10140 if (signature_in_table
== signature
)
10142 uint32_t unit_index
=
10143 read_4_bytes (dbfd
,
10144 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
10146 if (dwp_file
->version
== 1)
10148 *slot
= create_dwo_unit_in_dwp_v1 (dwp_file
, unit_index
,
10149 comp_dir
, signature
,
10154 *slot
= create_dwo_unit_in_dwp_v2 (dwp_file
, unit_index
,
10155 comp_dir
, signature
,
10160 if (signature_in_table
== 0)
10162 hash
= (hash
+ hash2
) & mask
;
10165 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10166 " [in module %s]"),
10170 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10171 Open the file specified by FILE_NAME and hand it off to BFD for
10172 preliminary analysis. Return a newly initialized bfd *, which
10173 includes a canonicalized copy of FILE_NAME.
10174 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10175 SEARCH_CWD is true if the current directory is to be searched.
10176 It will be searched before debug-file-directory.
10177 If successful, the file is added to the bfd include table of the
10178 objfile's bfd (see gdb_bfd_record_inclusion).
10179 If unable to find/open the file, return NULL.
10180 NOTE: This function is derived from symfile_bfd_open. */
10183 try_open_dwop_file (const char *file_name
, int is_dwp
, int search_cwd
)
10187 char *absolute_name
;
10188 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10189 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10190 to debug_file_directory. */
10192 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
10196 if (*debug_file_directory
!= '\0')
10197 search_path
= concat (".", dirname_separator_string
,
10198 debug_file_directory
, NULL
);
10200 search_path
= xstrdup (".");
10203 search_path
= xstrdup (debug_file_directory
);
10205 flags
= OPF_RETURN_REALPATH
;
10207 flags
|= OPF_SEARCH_IN_PATH
;
10208 desc
= openp (search_path
, flags
, file_name
,
10209 O_RDONLY
| O_BINARY
, &absolute_name
);
10210 xfree (search_path
);
10214 sym_bfd
= gdb_bfd_open (absolute_name
, gnutarget
, desc
);
10215 xfree (absolute_name
);
10216 if (sym_bfd
== NULL
)
10218 bfd_set_cacheable (sym_bfd
, 1);
10220 if (!bfd_check_format (sym_bfd
, bfd_object
))
10222 gdb_bfd_unref (sym_bfd
); /* This also closes desc. */
10226 /* Success. Record the bfd as having been included by the objfile's bfd.
10227 This is important because things like demangled_names_hash lives in the
10228 objfile's per_bfd space and may have references to things like symbol
10229 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10230 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
);
10235 /* Try to open DWO file FILE_NAME.
10236 COMP_DIR is the DW_AT_comp_dir attribute.
10237 The result is the bfd handle of the file.
10238 If there is a problem finding or opening the file, return NULL.
10239 Upon success, the canonicalized path of the file is stored in the bfd,
10240 same as symfile_bfd_open. */
10243 open_dwo_file (const char *file_name
, const char *comp_dir
)
10247 if (IS_ABSOLUTE_PATH (file_name
))
10248 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 0 /*search_cwd*/);
10250 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10252 if (comp_dir
!= NULL
)
10254 char *path_to_try
= concat (comp_dir
, SLASH_STRING
, file_name
, NULL
);
10256 /* NOTE: If comp_dir is a relative path, this will also try the
10257 search path, which seems useful. */
10258 abfd
= try_open_dwop_file (path_to_try
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10259 xfree (path_to_try
);
10264 /* That didn't work, try debug-file-directory, which, despite its name,
10265 is a list of paths. */
10267 if (*debug_file_directory
== '\0')
10270 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10273 /* This function is mapped across the sections and remembers the offset and
10274 size of each of the DWO debugging sections we are interested in. */
10277 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
10279 struct dwo_sections
*dwo_sections
= dwo_sections_ptr
;
10280 const struct dwop_section_names
*names
= &dwop_section_names
;
10282 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10284 dwo_sections
->abbrev
.s
.asection
= sectp
;
10285 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
10287 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10289 dwo_sections
->info
.s
.asection
= sectp
;
10290 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
10292 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10294 dwo_sections
->line
.s
.asection
= sectp
;
10295 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
10297 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10299 dwo_sections
->loc
.s
.asection
= sectp
;
10300 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
10302 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10304 dwo_sections
->macinfo
.s
.asection
= sectp
;
10305 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
10307 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10309 dwo_sections
->macro
.s
.asection
= sectp
;
10310 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
10312 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
10314 dwo_sections
->str
.s
.asection
= sectp
;
10315 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
10317 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10319 dwo_sections
->str_offsets
.s
.asection
= sectp
;
10320 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
10322 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10324 struct dwarf2_section_info type_section
;
10326 memset (&type_section
, 0, sizeof (type_section
));
10327 type_section
.s
.asection
= sectp
;
10328 type_section
.size
= bfd_get_section_size (sectp
);
10329 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
10334 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10335 by PER_CU. This is for the non-DWP case.
10336 The result is NULL if DWO_NAME can't be found. */
10338 static struct dwo_file
*
10339 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
10340 const char *dwo_name
, const char *comp_dir
)
10342 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10343 struct dwo_file
*dwo_file
;
10345 struct cleanup
*cleanups
;
10347 dbfd
= open_dwo_file (dwo_name
, comp_dir
);
10350 if (dwarf2_read_debug
)
10351 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
10354 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10355 dwo_file
->dwo_name
= dwo_name
;
10356 dwo_file
->comp_dir
= comp_dir
;
10357 dwo_file
->dbfd
= dbfd
;
10359 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
10361 bfd_map_over_sections (dbfd
, dwarf2_locate_dwo_sections
, &dwo_file
->sections
);
10363 dwo_file
->cu
= create_dwo_cu (dwo_file
);
10365 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
10366 dwo_file
->sections
.types
);
10368 discard_cleanups (cleanups
);
10370 if (dwarf2_read_debug
)
10371 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
10376 /* This function is mapped across the sections and remembers the offset and
10377 size of each of the DWP debugging sections common to version 1 and 2 that
10378 we are interested in. */
10381 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
10382 void *dwp_file_ptr
)
10384 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10385 const struct dwop_section_names
*names
= &dwop_section_names
;
10386 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10388 /* Record the ELF section number for later lookup: this is what the
10389 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10390 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10391 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10393 /* Look for specific sections that we need. */
10394 if (section_is_p (sectp
->name
, &names
->str_dwo
))
10396 dwp_file
->sections
.str
.s
.asection
= sectp
;
10397 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
10399 else if (section_is_p (sectp
->name
, &names
->cu_index
))
10401 dwp_file
->sections
.cu_index
.s
.asection
= sectp
;
10402 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
10404 else if (section_is_p (sectp
->name
, &names
->tu_index
))
10406 dwp_file
->sections
.tu_index
.s
.asection
= sectp
;
10407 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
10411 /* This function is mapped across the sections and remembers the offset and
10412 size of each of the DWP version 2 debugging sections that we are interested
10413 in. This is split into a separate function because we don't know if we
10414 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10417 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
10419 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10420 const struct dwop_section_names
*names
= &dwop_section_names
;
10421 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10423 /* Record the ELF section number for later lookup: this is what the
10424 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10425 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10426 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10428 /* Look for specific sections that we need. */
10429 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10431 dwp_file
->sections
.abbrev
.s
.asection
= sectp
;
10432 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
10434 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10436 dwp_file
->sections
.info
.s
.asection
= sectp
;
10437 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
10439 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10441 dwp_file
->sections
.line
.s
.asection
= sectp
;
10442 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
10444 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10446 dwp_file
->sections
.loc
.s
.asection
= sectp
;
10447 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
10449 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10451 dwp_file
->sections
.macinfo
.s
.asection
= sectp
;
10452 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
10454 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10456 dwp_file
->sections
.macro
.s
.asection
= sectp
;
10457 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
10459 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10461 dwp_file
->sections
.str_offsets
.s
.asection
= sectp
;
10462 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
10464 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10466 dwp_file
->sections
.types
.s
.asection
= sectp
;
10467 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
10471 /* Hash function for dwp_file loaded CUs/TUs. */
10474 hash_dwp_loaded_cutus (const void *item
)
10476 const struct dwo_unit
*dwo_unit
= item
;
10478 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10479 return dwo_unit
->signature
;
10482 /* Equality function for dwp_file loaded CUs/TUs. */
10485 eq_dwp_loaded_cutus (const void *a
, const void *b
)
10487 const struct dwo_unit
*dua
= a
;
10488 const struct dwo_unit
*dub
= b
;
10490 return dua
->signature
== dub
->signature
;
10493 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10496 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
10498 return htab_create_alloc_ex (3,
10499 hash_dwp_loaded_cutus
,
10500 eq_dwp_loaded_cutus
,
10502 &objfile
->objfile_obstack
,
10503 hashtab_obstack_allocate
,
10504 dummy_obstack_deallocate
);
10507 /* Try to open DWP file FILE_NAME.
10508 The result is the bfd handle of the file.
10509 If there is a problem finding or opening the file, return NULL.
10510 Upon success, the canonicalized path of the file is stored in the bfd,
10511 same as symfile_bfd_open. */
10514 open_dwp_file (const char *file_name
)
10518 abfd
= try_open_dwop_file (file_name
, 1 /*is_dwp*/, 1 /*search_cwd*/);
10522 /* Work around upstream bug 15652.
10523 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10524 [Whether that's a "bug" is debatable, but it is getting in our way.]
10525 We have no real idea where the dwp file is, because gdb's realpath-ing
10526 of the executable's path may have discarded the needed info.
10527 [IWBN if the dwp file name was recorded in the executable, akin to
10528 .gnu_debuglink, but that doesn't exist yet.]
10529 Strip the directory from FILE_NAME and search again. */
10530 if (*debug_file_directory
!= '\0')
10532 /* Don't implicitly search the current directory here.
10533 If the user wants to search "." to handle this case,
10534 it must be added to debug-file-directory. */
10535 return try_open_dwop_file (lbasename (file_name
), 1 /*is_dwp*/,
10542 /* Initialize the use of the DWP file for the current objfile.
10543 By convention the name of the DWP file is ${objfile}.dwp.
10544 The result is NULL if it can't be found. */
10546 static struct dwp_file
*
10547 open_and_init_dwp_file (void)
10549 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10550 struct dwp_file
*dwp_file
;
10553 struct cleanup
*cleanups
;
10555 /* Try to find first .dwp for the binary file before any symbolic links
10557 dwp_name
= xstrprintf ("%s.dwp", objfile
->original_name
);
10558 cleanups
= make_cleanup (xfree
, dwp_name
);
10560 dbfd
= open_dwp_file (dwp_name
);
10562 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
10564 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10565 dwp_name
= xstrprintf ("%s.dwp", objfile_name (objfile
));
10566 make_cleanup (xfree
, dwp_name
);
10567 dbfd
= open_dwp_file (dwp_name
);
10572 if (dwarf2_read_debug
)
10573 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
);
10574 do_cleanups (cleanups
);
10577 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
10578 dwp_file
->name
= bfd_get_filename (dbfd
);
10579 dwp_file
->dbfd
= dbfd
;
10580 do_cleanups (cleanups
);
10582 /* +1: section 0 is unused */
10583 dwp_file
->num_sections
= bfd_count_sections (dbfd
) + 1;
10584 dwp_file
->elf_sections
=
10585 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
10586 dwp_file
->num_sections
, asection
*);
10588 bfd_map_over_sections (dbfd
, dwarf2_locate_common_dwp_sections
, dwp_file
);
10590 dwp_file
->cus
= create_dwp_hash_table (dwp_file
, 0);
10592 dwp_file
->tus
= create_dwp_hash_table (dwp_file
, 1);
10594 /* The DWP file version is stored in the hash table. Oh well. */
10595 if (dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
10597 /* Technically speaking, we should try to limp along, but this is
10598 pretty bizarre. We use pulongest here because that's the established
10599 portability solution (e.g, we cannot use %u for uint32_t). */
10600 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10601 " TU version %s [in DWP file %s]"),
10602 pulongest (dwp_file
->cus
->version
),
10603 pulongest (dwp_file
->tus
->version
), dwp_name
);
10605 dwp_file
->version
= dwp_file
->cus
->version
;
10607 if (dwp_file
->version
== 2)
10608 bfd_map_over_sections (dbfd
, dwarf2_locate_v2_dwp_sections
, dwp_file
);
10610 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
10611 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
10613 if (dwarf2_read_debug
)
10615 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
10616 fprintf_unfiltered (gdb_stdlog
,
10617 " %s CUs, %s TUs\n",
10618 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
10619 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
10625 /* Wrapper around open_and_init_dwp_file, only open it once. */
10627 static struct dwp_file
*
10628 get_dwp_file (void)
10630 if (! dwarf2_per_objfile
->dwp_checked
)
10632 dwarf2_per_objfile
->dwp_file
= open_and_init_dwp_file ();
10633 dwarf2_per_objfile
->dwp_checked
= 1;
10635 return dwarf2_per_objfile
->dwp_file
;
10638 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10639 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10640 or in the DWP file for the objfile, referenced by THIS_UNIT.
10641 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10642 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10644 This is called, for example, when wanting to read a variable with a
10645 complex location. Therefore we don't want to do file i/o for every call.
10646 Therefore we don't want to look for a DWO file on every call.
10647 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10648 then we check if we've already seen DWO_NAME, and only THEN do we check
10651 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10652 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10654 static struct dwo_unit
*
10655 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
10656 const char *dwo_name
, const char *comp_dir
,
10657 ULONGEST signature
, int is_debug_types
)
10659 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10660 const char *kind
= is_debug_types
? "TU" : "CU";
10661 void **dwo_file_slot
;
10662 struct dwo_file
*dwo_file
;
10663 struct dwp_file
*dwp_file
;
10665 /* First see if there's a DWP file.
10666 If we have a DWP file but didn't find the DWO inside it, don't
10667 look for the original DWO file. It makes gdb behave differently
10668 depending on whether one is debugging in the build tree. */
10670 dwp_file
= get_dwp_file ();
10671 if (dwp_file
!= NULL
)
10673 const struct dwp_hash_table
*dwp_htab
=
10674 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10676 if (dwp_htab
!= NULL
)
10678 struct dwo_unit
*dwo_cutu
=
10679 lookup_dwo_unit_in_dwp (dwp_file
, comp_dir
,
10680 signature
, is_debug_types
);
10682 if (dwo_cutu
!= NULL
)
10684 if (dwarf2_read_debug
)
10686 fprintf_unfiltered (gdb_stdlog
,
10687 "Virtual DWO %s %s found: @%s\n",
10688 kind
, hex_string (signature
),
10689 host_address_to_string (dwo_cutu
));
10697 /* No DWP file, look for the DWO file. */
10699 dwo_file_slot
= lookup_dwo_file_slot (dwo_name
, comp_dir
);
10700 if (*dwo_file_slot
== NULL
)
10702 /* Read in the file and build a table of the CUs/TUs it contains. */
10703 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
10705 /* NOTE: This will be NULL if unable to open the file. */
10706 dwo_file
= *dwo_file_slot
;
10708 if (dwo_file
!= NULL
)
10710 struct dwo_unit
*dwo_cutu
= NULL
;
10712 if (is_debug_types
&& dwo_file
->tus
)
10714 struct dwo_unit find_dwo_cutu
;
10716 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
10717 find_dwo_cutu
.signature
= signature
;
10718 dwo_cutu
= htab_find (dwo_file
->tus
, &find_dwo_cutu
);
10720 else if (!is_debug_types
&& dwo_file
->cu
)
10722 if (signature
== dwo_file
->cu
->signature
)
10723 dwo_cutu
= dwo_file
->cu
;
10726 if (dwo_cutu
!= NULL
)
10728 if (dwarf2_read_debug
)
10730 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
10731 kind
, dwo_name
, hex_string (signature
),
10732 host_address_to_string (dwo_cutu
));
10739 /* We didn't find it. This could mean a dwo_id mismatch, or
10740 someone deleted the DWO/DWP file, or the search path isn't set up
10741 correctly to find the file. */
10743 if (dwarf2_read_debug
)
10745 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
10746 kind
, dwo_name
, hex_string (signature
));
10749 /* This is a warning and not a complaint because it can be caused by
10750 pilot error (e.g., user accidentally deleting the DWO). */
10752 /* Print the name of the DWP file if we looked there, helps the user
10753 better diagnose the problem. */
10754 char *dwp_text
= NULL
;
10755 struct cleanup
*cleanups
;
10757 if (dwp_file
!= NULL
)
10758 dwp_text
= xstrprintf (" [in DWP file %s]", lbasename (dwp_file
->name
));
10759 cleanups
= make_cleanup (xfree
, dwp_text
);
10761 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
10762 " [in module %s]"),
10763 kind
, dwo_name
, hex_string (signature
),
10764 dwp_text
!= NULL
? dwp_text
: "",
10765 this_unit
->is_debug_types
? "TU" : "CU",
10766 this_unit
->offset
.sect_off
, objfile_name (objfile
));
10768 do_cleanups (cleanups
);
10773 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
10774 See lookup_dwo_cutu_unit for details. */
10776 static struct dwo_unit
*
10777 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
10778 const char *dwo_name
, const char *comp_dir
,
10779 ULONGEST signature
)
10781 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
10784 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
10785 See lookup_dwo_cutu_unit for details. */
10787 static struct dwo_unit
*
10788 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
10789 const char *dwo_name
, const char *comp_dir
)
10791 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
10794 /* Traversal function for queue_and_load_all_dwo_tus. */
10797 queue_and_load_dwo_tu (void **slot
, void *info
)
10799 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
10800 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
10801 ULONGEST signature
= dwo_unit
->signature
;
10802 struct signatured_type
*sig_type
=
10803 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
10805 if (sig_type
!= NULL
)
10807 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
10809 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
10810 a real dependency of PER_CU on SIG_TYPE. That is detected later
10811 while processing PER_CU. */
10812 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
10813 load_full_type_unit (sig_cu
);
10814 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
10820 /* Queue all TUs contained in the DWO of PER_CU to be read in.
10821 The DWO may have the only definition of the type, though it may not be
10822 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
10823 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
10826 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
10828 struct dwo_unit
*dwo_unit
;
10829 struct dwo_file
*dwo_file
;
10831 gdb_assert (!per_cu
->is_debug_types
);
10832 gdb_assert (get_dwp_file () == NULL
);
10833 gdb_assert (per_cu
->cu
!= NULL
);
10835 dwo_unit
= per_cu
->cu
->dwo_unit
;
10836 gdb_assert (dwo_unit
!= NULL
);
10838 dwo_file
= dwo_unit
->dwo_file
;
10839 if (dwo_file
->tus
!= NULL
)
10840 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
10843 /* Free all resources associated with DWO_FILE.
10844 Close the DWO file and munmap the sections.
10845 All memory should be on the objfile obstack. */
10848 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
10851 struct dwarf2_section_info
*section
;
10853 /* Note: dbfd is NULL for virtual DWO files. */
10854 gdb_bfd_unref (dwo_file
->dbfd
);
10856 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
10859 /* Wrapper for free_dwo_file for use in cleanups. */
10862 free_dwo_file_cleanup (void *arg
)
10864 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
10865 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10867 free_dwo_file (dwo_file
, objfile
);
10870 /* Traversal function for free_dwo_files. */
10873 free_dwo_file_from_slot (void **slot
, void *info
)
10875 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
10876 struct objfile
*objfile
= (struct objfile
*) info
;
10878 free_dwo_file (dwo_file
, objfile
);
10883 /* Free all resources associated with DWO_FILES. */
10886 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
10888 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
10891 /* Read in various DIEs. */
10893 /* qsort helper for inherit_abstract_dies. */
10896 unsigned_int_compar (const void *ap
, const void *bp
)
10898 unsigned int a
= *(unsigned int *) ap
;
10899 unsigned int b
= *(unsigned int *) bp
;
10901 return (a
> b
) - (b
> a
);
10904 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
10905 Inherit only the children of the DW_AT_abstract_origin DIE not being
10906 already referenced by DW_AT_abstract_origin from the children of the
10910 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
10912 struct die_info
*child_die
;
10913 unsigned die_children_count
;
10914 /* CU offsets which were referenced by children of the current DIE. */
10915 sect_offset
*offsets
;
10916 sect_offset
*offsets_end
, *offsetp
;
10917 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
10918 struct die_info
*origin_die
;
10919 /* Iterator of the ORIGIN_DIE children. */
10920 struct die_info
*origin_child_die
;
10921 struct cleanup
*cleanups
;
10922 struct attribute
*attr
;
10923 struct dwarf2_cu
*origin_cu
;
10924 struct pending
**origin_previous_list_in_scope
;
10926 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
10930 /* Note that following die references may follow to a die in a
10934 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
10936 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
10938 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
10939 origin_cu
->list_in_scope
= cu
->list_in_scope
;
10941 if (die
->tag
!= origin_die
->tag
10942 && !(die
->tag
== DW_TAG_inlined_subroutine
10943 && origin_die
->tag
== DW_TAG_subprogram
))
10944 complaint (&symfile_complaints
,
10945 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
10946 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
10948 child_die
= die
->child
;
10949 die_children_count
= 0;
10950 while (child_die
&& child_die
->tag
)
10952 child_die
= sibling_die (child_die
);
10953 die_children_count
++;
10955 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
10956 cleanups
= make_cleanup (xfree
, offsets
);
10958 offsets_end
= offsets
;
10959 child_die
= die
->child
;
10960 while (child_die
&& child_die
->tag
)
10962 /* For each CHILD_DIE, find the corresponding child of
10963 ORIGIN_DIE. If there is more than one layer of
10964 DW_AT_abstract_origin, follow them all; there shouldn't be,
10965 but GCC versions at least through 4.4 generate this (GCC PR
10967 struct die_info
*child_origin_die
= child_die
;
10968 struct dwarf2_cu
*child_origin_cu
= cu
;
10972 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
10976 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
10980 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
10981 counterpart may exist. */
10982 if (child_origin_die
!= child_die
)
10984 if (child_die
->tag
!= child_origin_die
->tag
10985 && !(child_die
->tag
== DW_TAG_inlined_subroutine
10986 && child_origin_die
->tag
== DW_TAG_subprogram
))
10987 complaint (&symfile_complaints
,
10988 _("Child DIE 0x%x and its abstract origin 0x%x have "
10989 "different tags"), child_die
->offset
.sect_off
,
10990 child_origin_die
->offset
.sect_off
);
10991 if (child_origin_die
->parent
!= origin_die
)
10992 complaint (&symfile_complaints
,
10993 _("Child DIE 0x%x and its abstract origin 0x%x have "
10994 "different parents"), child_die
->offset
.sect_off
,
10995 child_origin_die
->offset
.sect_off
);
10997 *offsets_end
++ = child_origin_die
->offset
;
10999 child_die
= sibling_die (child_die
);
11001 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
11002 unsigned_int_compar
);
11003 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
11004 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
11005 complaint (&symfile_complaints
,
11006 _("Multiple children of DIE 0x%x refer "
11007 "to DIE 0x%x as their abstract origin"),
11008 die
->offset
.sect_off
, offsetp
->sect_off
);
11011 origin_child_die
= origin_die
->child
;
11012 while (origin_child_die
&& origin_child_die
->tag
)
11014 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11015 while (offsetp
< offsets_end
11016 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
11018 if (offsetp
>= offsets_end
11019 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
11021 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11022 Check whether we're already processing ORIGIN_CHILD_DIE.
11023 This can happen with mutually referenced abstract_origins.
11025 if (!origin_child_die
->in_process
)
11026 process_die (origin_child_die
, origin_cu
);
11028 origin_child_die
= sibling_die (origin_child_die
);
11030 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
11032 do_cleanups (cleanups
);
11036 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11038 struct objfile
*objfile
= cu
->objfile
;
11039 struct context_stack
*new;
11042 struct die_info
*child_die
;
11043 struct attribute
*attr
, *call_line
, *call_file
;
11045 CORE_ADDR baseaddr
;
11046 struct block
*block
;
11047 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11048 VEC (symbolp
) *template_args
= NULL
;
11049 struct template_symbol
*templ_func
= NULL
;
11053 /* If we do not have call site information, we can't show the
11054 caller of this inlined function. That's too confusing, so
11055 only use the scope for local variables. */
11056 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
11057 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
11058 if (call_line
== NULL
|| call_file
== NULL
)
11060 read_lexical_block_scope (die
, cu
);
11065 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11067 name
= dwarf2_name (die
, cu
);
11069 /* Ignore functions with missing or empty names. These are actually
11070 illegal according to the DWARF standard. */
11073 complaint (&symfile_complaints
,
11074 _("missing name for subprogram DIE at %d"),
11075 die
->offset
.sect_off
);
11079 /* Ignore functions with missing or invalid low and high pc attributes. */
11080 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11082 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
11083 if (!attr
|| !DW_UNSND (attr
))
11084 complaint (&symfile_complaints
,
11085 _("cannot get low and high bounds "
11086 "for subprogram DIE at %d"),
11087 die
->offset
.sect_off
);
11092 highpc
+= baseaddr
;
11094 /* If we have any template arguments, then we must allocate a
11095 different sort of symbol. */
11096 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
11098 if (child_die
->tag
== DW_TAG_template_type_param
11099 || child_die
->tag
== DW_TAG_template_value_param
)
11101 templ_func
= allocate_template_symbol (objfile
);
11102 templ_func
->base
.is_cplus_template_function
= 1;
11107 new = push_context (0, lowpc
);
11108 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
11109 (struct symbol
*) templ_func
);
11111 /* If there is a location expression for DW_AT_frame_base, record
11113 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
11115 dwarf2_symbol_mark_computed (attr
, new->name
, cu
, 1);
11117 cu
->list_in_scope
= &local_symbols
;
11119 if (die
->child
!= NULL
)
11121 child_die
= die
->child
;
11122 while (child_die
&& child_die
->tag
)
11124 if (child_die
->tag
== DW_TAG_template_type_param
11125 || child_die
->tag
== DW_TAG_template_value_param
)
11127 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
11130 VEC_safe_push (symbolp
, template_args
, arg
);
11133 process_die (child_die
, cu
);
11134 child_die
= sibling_die (child_die
);
11138 inherit_abstract_dies (die
, cu
);
11140 /* If we have a DW_AT_specification, we might need to import using
11141 directives from the context of the specification DIE. See the
11142 comment in determine_prefix. */
11143 if (cu
->language
== language_cplus
11144 && dwarf2_attr (die
, DW_AT_specification
, cu
))
11146 struct dwarf2_cu
*spec_cu
= cu
;
11147 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
11151 child_die
= spec_die
->child
;
11152 while (child_die
&& child_die
->tag
)
11154 if (child_die
->tag
== DW_TAG_imported_module
)
11155 process_die (child_die
, spec_cu
);
11156 child_die
= sibling_die (child_die
);
11159 /* In some cases, GCC generates specification DIEs that
11160 themselves contain DW_AT_specification attributes. */
11161 spec_die
= die_specification (spec_die
, &spec_cu
);
11165 new = pop_context ();
11166 /* Make a block for the local symbols within. */
11167 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
11168 lowpc
, highpc
, objfile
);
11170 /* For C++, set the block's scope. */
11171 if ((cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
11172 && cu
->processing_has_namespace_info
)
11173 block_set_scope (block
, determine_prefix (die
, cu
),
11174 &objfile
->objfile_obstack
);
11176 /* If we have address ranges, record them. */
11177 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11179 /* Attach template arguments to function. */
11180 if (! VEC_empty (symbolp
, template_args
))
11182 gdb_assert (templ_func
!= NULL
);
11184 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
11185 templ_func
->template_arguments
11186 = obstack_alloc (&objfile
->objfile_obstack
,
11187 (templ_func
->n_template_arguments
11188 * sizeof (struct symbol
*)));
11189 memcpy (templ_func
->template_arguments
,
11190 VEC_address (symbolp
, template_args
),
11191 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
11192 VEC_free (symbolp
, template_args
);
11195 /* In C++, we can have functions nested inside functions (e.g., when
11196 a function declares a class that has methods). This means that
11197 when we finish processing a function scope, we may need to go
11198 back to building a containing block's symbol lists. */
11199 local_symbols
= new->locals
;
11200 using_directives
= new->using_directives
;
11202 /* If we've finished processing a top-level function, subsequent
11203 symbols go in the file symbol list. */
11204 if (outermost_context_p ())
11205 cu
->list_in_scope
= &file_symbols
;
11208 /* Process all the DIES contained within a lexical block scope. Start
11209 a new scope, process the dies, and then close the scope. */
11212 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11214 struct objfile
*objfile
= cu
->objfile
;
11215 struct context_stack
*new;
11216 CORE_ADDR lowpc
, highpc
;
11217 struct die_info
*child_die
;
11218 CORE_ADDR baseaddr
;
11220 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11222 /* Ignore blocks with missing or invalid low and high pc attributes. */
11223 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11224 as multiple lexical blocks? Handling children in a sane way would
11225 be nasty. Might be easier to properly extend generic blocks to
11226 describe ranges. */
11227 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11230 highpc
+= baseaddr
;
11232 push_context (0, lowpc
);
11233 if (die
->child
!= NULL
)
11235 child_die
= die
->child
;
11236 while (child_die
&& child_die
->tag
)
11238 process_die (child_die
, cu
);
11239 child_die
= sibling_die (child_die
);
11242 new = pop_context ();
11244 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
11246 struct block
*block
11247 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
11250 /* Note that recording ranges after traversing children, as we
11251 do here, means that recording a parent's ranges entails
11252 walking across all its children's ranges as they appear in
11253 the address map, which is quadratic behavior.
11255 It would be nicer to record the parent's ranges before
11256 traversing its children, simply overriding whatever you find
11257 there. But since we don't even decide whether to create a
11258 block until after we've traversed its children, that's hard
11260 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11262 local_symbols
= new->locals
;
11263 using_directives
= new->using_directives
;
11266 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11269 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11271 struct objfile
*objfile
= cu
->objfile
;
11272 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11273 CORE_ADDR pc
, baseaddr
;
11274 struct attribute
*attr
;
11275 struct call_site
*call_site
, call_site_local
;
11278 struct die_info
*child_die
;
11280 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11282 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11285 complaint (&symfile_complaints
,
11286 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11287 "DIE 0x%x [in module %s]"),
11288 die
->offset
.sect_off
, objfile_name (objfile
));
11291 pc
= attr_value_as_address (attr
) + baseaddr
;
11293 if (cu
->call_site_htab
== NULL
)
11294 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
11295 NULL
, &objfile
->objfile_obstack
,
11296 hashtab_obstack_allocate
, NULL
);
11297 call_site_local
.pc
= pc
;
11298 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
11301 complaint (&symfile_complaints
,
11302 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11303 "DIE 0x%x [in module %s]"),
11304 paddress (gdbarch
, pc
), die
->offset
.sect_off
,
11305 objfile_name (objfile
));
11309 /* Count parameters at the caller. */
11312 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11313 child_die
= sibling_die (child_die
))
11315 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11317 complaint (&symfile_complaints
,
11318 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11319 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11320 child_die
->tag
, child_die
->offset
.sect_off
,
11321 objfile_name (objfile
));
11328 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
11329 (sizeof (*call_site
)
11330 + (sizeof (*call_site
->parameter
)
11331 * (nparams
- 1))));
11333 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
11334 call_site
->pc
= pc
;
11336 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
11338 struct die_info
*func_die
;
11340 /* Skip also over DW_TAG_inlined_subroutine. */
11341 for (func_die
= die
->parent
;
11342 func_die
&& func_die
->tag
!= DW_TAG_subprogram
11343 && func_die
->tag
!= DW_TAG_subroutine_type
;
11344 func_die
= func_die
->parent
);
11346 /* DW_AT_GNU_all_call_sites is a superset
11347 of DW_AT_GNU_all_tail_call_sites. */
11349 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
11350 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
11352 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11353 not complete. But keep CALL_SITE for look ups via call_site_htab,
11354 both the initial caller containing the real return address PC and
11355 the final callee containing the current PC of a chain of tail
11356 calls do not need to have the tail call list complete. But any
11357 function candidate for a virtual tail call frame searched via
11358 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11359 determined unambiguously. */
11363 struct type
*func_type
= NULL
;
11366 func_type
= get_die_type (func_die
, cu
);
11367 if (func_type
!= NULL
)
11369 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
11371 /* Enlist this call site to the function. */
11372 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
11373 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
11376 complaint (&symfile_complaints
,
11377 _("Cannot find function owning DW_TAG_GNU_call_site "
11378 "DIE 0x%x [in module %s]"),
11379 die
->offset
.sect_off
, objfile_name (objfile
));
11383 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
11385 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11386 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
11387 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
11388 /* Keep NULL DWARF_BLOCK. */;
11389 else if (attr_form_is_block (attr
))
11391 struct dwarf2_locexpr_baton
*dlbaton
;
11393 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
11394 dlbaton
->data
= DW_BLOCK (attr
)->data
;
11395 dlbaton
->size
= DW_BLOCK (attr
)->size
;
11396 dlbaton
->per_cu
= cu
->per_cu
;
11398 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
11400 else if (attr_form_is_ref (attr
))
11402 struct dwarf2_cu
*target_cu
= cu
;
11403 struct die_info
*target_die
;
11405 target_die
= follow_die_ref (die
, attr
, &target_cu
);
11406 gdb_assert (target_cu
->objfile
== objfile
);
11407 if (die_is_declaration (target_die
, target_cu
))
11409 const char *target_physname
= NULL
;
11410 struct attribute
*target_attr
;
11412 /* Prefer the mangled name; otherwise compute the demangled one. */
11413 target_attr
= dwarf2_attr (target_die
, DW_AT_linkage_name
, target_cu
);
11414 if (target_attr
== NULL
)
11415 target_attr
= dwarf2_attr (target_die
, DW_AT_MIPS_linkage_name
,
11417 if (target_attr
!= NULL
&& DW_STRING (target_attr
) != NULL
)
11418 target_physname
= DW_STRING (target_attr
);
11420 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
11421 if (target_physname
== NULL
)
11422 complaint (&symfile_complaints
,
11423 _("DW_AT_GNU_call_site_target target DIE has invalid "
11424 "physname, for referencing DIE 0x%x [in module %s]"),
11425 die
->offset
.sect_off
, objfile_name (objfile
));
11427 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
11433 /* DW_AT_entry_pc should be preferred. */
11434 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
11435 complaint (&symfile_complaints
,
11436 _("DW_AT_GNU_call_site_target target DIE has invalid "
11437 "low pc, for referencing DIE 0x%x [in module %s]"),
11438 die
->offset
.sect_off
, objfile_name (objfile
));
11440 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
11444 complaint (&symfile_complaints
,
11445 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11446 "block nor reference, for DIE 0x%x [in module %s]"),
11447 die
->offset
.sect_off
, objfile_name (objfile
));
11449 call_site
->per_cu
= cu
->per_cu
;
11451 for (child_die
= die
->child
;
11452 child_die
&& child_die
->tag
;
11453 child_die
= sibling_die (child_die
))
11455 struct call_site_parameter
*parameter
;
11456 struct attribute
*loc
, *origin
;
11458 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11460 /* Already printed the complaint above. */
11464 gdb_assert (call_site
->parameter_count
< nparams
);
11465 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
11467 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11468 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11469 register is contained in DW_AT_GNU_call_site_value. */
11471 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
11472 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
11473 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
11475 sect_offset offset
;
11477 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
11478 offset
= dwarf2_get_ref_die_offset (origin
);
11479 if (!offset_in_cu_p (&cu
->header
, offset
))
11481 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11482 binding can be done only inside one CU. Such referenced DIE
11483 therefore cannot be even moved to DW_TAG_partial_unit. */
11484 complaint (&symfile_complaints
,
11485 _("DW_AT_abstract_origin offset is not in CU for "
11486 "DW_TAG_GNU_call_site child DIE 0x%x "
11488 child_die
->offset
.sect_off
, objfile_name (objfile
));
11491 parameter
->u
.param_offset
.cu_off
= (offset
.sect_off
11492 - cu
->header
.offset
.sect_off
);
11494 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
11496 complaint (&symfile_complaints
,
11497 _("No DW_FORM_block* DW_AT_location for "
11498 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11499 child_die
->offset
.sect_off
, objfile_name (objfile
));
11504 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
11505 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
11506 if (parameter
->u
.dwarf_reg
!= -1)
11507 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
11508 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
11509 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
11510 ¶meter
->u
.fb_offset
))
11511 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
11514 complaint (&symfile_complaints
,
11515 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11516 "for DW_FORM_block* DW_AT_location is supported for "
11517 "DW_TAG_GNU_call_site child DIE 0x%x "
11519 child_die
->offset
.sect_off
, objfile_name (objfile
));
11524 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
11525 if (!attr_form_is_block (attr
))
11527 complaint (&symfile_complaints
,
11528 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11529 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11530 child_die
->offset
.sect_off
, objfile_name (objfile
));
11533 parameter
->value
= DW_BLOCK (attr
)->data
;
11534 parameter
->value_size
= DW_BLOCK (attr
)->size
;
11536 /* Parameters are not pre-cleared by memset above. */
11537 parameter
->data_value
= NULL
;
11538 parameter
->data_value_size
= 0;
11539 call_site
->parameter_count
++;
11541 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
11544 if (!attr_form_is_block (attr
))
11545 complaint (&symfile_complaints
,
11546 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11547 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11548 child_die
->offset
.sect_off
, objfile_name (objfile
));
11551 parameter
->data_value
= DW_BLOCK (attr
)->data
;
11552 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
11558 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11559 Return 1 if the attributes are present and valid, otherwise, return 0.
11560 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11563 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
11564 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
11565 struct partial_symtab
*ranges_pst
)
11567 struct objfile
*objfile
= cu
->objfile
;
11568 struct comp_unit_head
*cu_header
= &cu
->header
;
11569 bfd
*obfd
= objfile
->obfd
;
11570 unsigned int addr_size
= cu_header
->addr_size
;
11571 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
11572 /* Base address selection entry. */
11575 unsigned int dummy
;
11576 const gdb_byte
*buffer
;
11580 CORE_ADDR high
= 0;
11581 CORE_ADDR baseaddr
;
11583 found_base
= cu
->base_known
;
11584 base
= cu
->base_address
;
11586 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
11587 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
11589 complaint (&symfile_complaints
,
11590 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11594 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
11596 /* Read in the largest possible address. */
11597 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
11598 if ((marker
& mask
) == mask
)
11600 /* If we found the largest possible address, then
11601 read the base address. */
11602 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11603 buffer
+= 2 * addr_size
;
11604 offset
+= 2 * addr_size
;
11610 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11614 CORE_ADDR range_beginning
, range_end
;
11616 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
11617 buffer
+= addr_size
;
11618 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
11619 buffer
+= addr_size
;
11620 offset
+= 2 * addr_size
;
11622 /* An end of list marker is a pair of zero addresses. */
11623 if (range_beginning
== 0 && range_end
== 0)
11624 /* Found the end of list entry. */
11627 /* Each base address selection entry is a pair of 2 values.
11628 The first is the largest possible address, the second is
11629 the base address. Check for a base address here. */
11630 if ((range_beginning
& mask
) == mask
)
11632 /* If we found the largest possible address, then
11633 read the base address. */
11634 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11641 /* We have no valid base address for the ranges
11643 complaint (&symfile_complaints
,
11644 _("Invalid .debug_ranges data (no base address)"));
11648 if (range_beginning
> range_end
)
11650 /* Inverted range entries are invalid. */
11651 complaint (&symfile_complaints
,
11652 _("Invalid .debug_ranges data (inverted range)"));
11656 /* Empty range entries have no effect. */
11657 if (range_beginning
== range_end
)
11660 range_beginning
+= base
;
11663 /* A not-uncommon case of bad debug info.
11664 Don't pollute the addrmap with bad data. */
11665 if (range_beginning
+ baseaddr
== 0
11666 && !dwarf2_per_objfile
->has_section_at_zero
)
11668 complaint (&symfile_complaints
,
11669 _(".debug_ranges entry has start address of zero"
11670 " [in module %s]"), objfile_name (objfile
));
11674 if (ranges_pst
!= NULL
)
11675 addrmap_set_empty (objfile
->psymtabs_addrmap
,
11676 range_beginning
+ baseaddr
,
11677 range_end
- 1 + baseaddr
,
11680 /* FIXME: This is recording everything as a low-high
11681 segment of consecutive addresses. We should have a
11682 data structure for discontiguous block ranges
11686 low
= range_beginning
;
11692 if (range_beginning
< low
)
11693 low
= range_beginning
;
11694 if (range_end
> high
)
11700 /* If the first entry is an end-of-list marker, the range
11701 describes an empty scope, i.e. no instructions. */
11707 *high_return
= high
;
11711 /* Get low and high pc attributes from a die. Return 1 if the attributes
11712 are present and valid, otherwise, return 0. Return -1 if the range is
11713 discontinuous, i.e. derived from DW_AT_ranges information. */
11716 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
11717 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
11718 struct partial_symtab
*pst
)
11720 struct attribute
*attr
;
11721 struct attribute
*attr_high
;
11723 CORE_ADDR high
= 0;
11726 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
11729 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11732 low
= attr_value_as_address (attr
);
11733 high
= attr_value_as_address (attr_high
);
11734 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
11738 /* Found high w/o low attribute. */
11741 /* Found consecutive range of addresses. */
11746 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
11749 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11750 We take advantage of the fact that DW_AT_ranges does not appear
11751 in DW_TAG_compile_unit of DWO files. */
11752 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
11753 unsigned int ranges_offset
= (DW_UNSND (attr
)
11754 + (need_ranges_base
11758 /* Value of the DW_AT_ranges attribute is the offset in the
11759 .debug_ranges section. */
11760 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
11762 /* Found discontinuous range of addresses. */
11767 /* read_partial_die has also the strict LOW < HIGH requirement. */
11771 /* When using the GNU linker, .gnu.linkonce. sections are used to
11772 eliminate duplicate copies of functions and vtables and such.
11773 The linker will arbitrarily choose one and discard the others.
11774 The AT_*_pc values for such functions refer to local labels in
11775 these sections. If the section from that file was discarded, the
11776 labels are not in the output, so the relocs get a value of 0.
11777 If this is a discarded function, mark the pc bounds as invalid,
11778 so that GDB will ignore it. */
11779 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
11788 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
11789 its low and high PC addresses. Do nothing if these addresses could not
11790 be determined. Otherwise, set LOWPC to the low address if it is smaller,
11791 and HIGHPC to the high address if greater than HIGHPC. */
11794 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
11795 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
11796 struct dwarf2_cu
*cu
)
11798 CORE_ADDR low
, high
;
11799 struct die_info
*child
= die
->child
;
11801 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
11803 *lowpc
= min (*lowpc
, low
);
11804 *highpc
= max (*highpc
, high
);
11807 /* If the language does not allow nested subprograms (either inside
11808 subprograms or lexical blocks), we're done. */
11809 if (cu
->language
!= language_ada
)
11812 /* Check all the children of the given DIE. If it contains nested
11813 subprograms, then check their pc bounds. Likewise, we need to
11814 check lexical blocks as well, as they may also contain subprogram
11816 while (child
&& child
->tag
)
11818 if (child
->tag
== DW_TAG_subprogram
11819 || child
->tag
== DW_TAG_lexical_block
)
11820 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
11821 child
= sibling_die (child
);
11825 /* Get the low and high pc's represented by the scope DIE, and store
11826 them in *LOWPC and *HIGHPC. If the correct values can't be
11827 determined, set *LOWPC to -1 and *HIGHPC to 0. */
11830 get_scope_pc_bounds (struct die_info
*die
,
11831 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
11832 struct dwarf2_cu
*cu
)
11834 CORE_ADDR best_low
= (CORE_ADDR
) -1;
11835 CORE_ADDR best_high
= (CORE_ADDR
) 0;
11836 CORE_ADDR current_low
, current_high
;
11838 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
11840 best_low
= current_low
;
11841 best_high
= current_high
;
11845 struct die_info
*child
= die
->child
;
11847 while (child
&& child
->tag
)
11849 switch (child
->tag
) {
11850 case DW_TAG_subprogram
:
11851 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
11853 case DW_TAG_namespace
:
11854 case DW_TAG_module
:
11855 /* FIXME: carlton/2004-01-16: Should we do this for
11856 DW_TAG_class_type/DW_TAG_structure_type, too? I think
11857 that current GCC's always emit the DIEs corresponding
11858 to definitions of methods of classes as children of a
11859 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
11860 the DIEs giving the declarations, which could be
11861 anywhere). But I don't see any reason why the
11862 standards says that they have to be there. */
11863 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
11865 if (current_low
!= ((CORE_ADDR
) -1))
11867 best_low
= min (best_low
, current_low
);
11868 best_high
= max (best_high
, current_high
);
11876 child
= sibling_die (child
);
11881 *highpc
= best_high
;
11884 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
11888 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
11889 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
11891 struct objfile
*objfile
= cu
->objfile
;
11892 struct attribute
*attr
;
11893 struct attribute
*attr_high
;
11895 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
11898 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11901 CORE_ADDR low
= attr_value_as_address (attr
);
11902 CORE_ADDR high
= attr_value_as_address (attr_high
);
11904 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
11907 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
11911 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
11914 bfd
*obfd
= objfile
->obfd
;
11915 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11916 We take advantage of the fact that DW_AT_ranges does not appear
11917 in DW_TAG_compile_unit of DWO files. */
11918 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
11920 /* The value of the DW_AT_ranges attribute is the offset of the
11921 address range list in the .debug_ranges section. */
11922 unsigned long offset
= (DW_UNSND (attr
)
11923 + (need_ranges_base
? cu
->ranges_base
: 0));
11924 const gdb_byte
*buffer
;
11926 /* For some target architectures, but not others, the
11927 read_address function sign-extends the addresses it returns.
11928 To recognize base address selection entries, we need a
11930 unsigned int addr_size
= cu
->header
.addr_size
;
11931 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
11933 /* The base address, to which the next pair is relative. Note
11934 that this 'base' is a DWARF concept: most entries in a range
11935 list are relative, to reduce the number of relocs against the
11936 debugging information. This is separate from this function's
11937 'baseaddr' argument, which GDB uses to relocate debugging
11938 information from a shared library based on the address at
11939 which the library was loaded. */
11940 CORE_ADDR base
= cu
->base_address
;
11941 int base_known
= cu
->base_known
;
11943 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
11944 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
11946 complaint (&symfile_complaints
,
11947 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
11951 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
11955 unsigned int bytes_read
;
11956 CORE_ADDR start
, end
;
11958 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
11959 buffer
+= bytes_read
;
11960 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
11961 buffer
+= bytes_read
;
11963 /* Did we find the end of the range list? */
11964 if (start
== 0 && end
== 0)
11967 /* Did we find a base address selection entry? */
11968 else if ((start
& base_select_mask
) == base_select_mask
)
11974 /* We found an ordinary address range. */
11979 complaint (&symfile_complaints
,
11980 _("Invalid .debug_ranges data "
11981 "(no base address)"));
11987 /* Inverted range entries are invalid. */
11988 complaint (&symfile_complaints
,
11989 _("Invalid .debug_ranges data "
11990 "(inverted range)"));
11994 /* Empty range entries have no effect. */
11998 start
+= base
+ baseaddr
;
11999 end
+= base
+ baseaddr
;
12001 /* A not-uncommon case of bad debug info.
12002 Don't pollute the addrmap with bad data. */
12003 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12005 complaint (&symfile_complaints
,
12006 _(".debug_ranges entry has start address of zero"
12007 " [in module %s]"), objfile_name (objfile
));
12011 record_block_range (block
, start
, end
- 1);
12017 /* Check whether the producer field indicates either of GCC < 4.6, or the
12018 Intel C/C++ compiler, and cache the result in CU. */
12021 check_producer (struct dwarf2_cu
*cu
)
12024 int major
, minor
, release
;
12026 if (cu
->producer
== NULL
)
12028 /* For unknown compilers expect their behavior is DWARF version
12031 GCC started to support .debug_types sections by -gdwarf-4 since
12032 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12033 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12034 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12035 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12037 else if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) == 0)
12039 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
12041 cs
= &cu
->producer
[strlen ("GNU ")];
12042 while (*cs
&& !isdigit (*cs
))
12044 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
12046 /* Not recognized as GCC. */
12050 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
12051 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
12054 else if (strncmp (cu
->producer
, "Intel(R) C", strlen ("Intel(R) C")) == 0)
12055 cu
->producer_is_icc
= 1;
12058 /* For other non-GCC compilers, expect their behavior is DWARF version
12062 cu
->checked_producer
= 1;
12065 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12066 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12067 during 4.6.0 experimental. */
12070 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
12072 if (!cu
->checked_producer
)
12073 check_producer (cu
);
12075 return cu
->producer_is_gxx_lt_4_6
;
12078 /* Return the default accessibility type if it is not overriden by
12079 DW_AT_accessibility. */
12081 static enum dwarf_access_attribute
12082 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
12084 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
12086 /* The default DWARF 2 accessibility for members is public, the default
12087 accessibility for inheritance is private. */
12089 if (die
->tag
!= DW_TAG_inheritance
)
12090 return DW_ACCESS_public
;
12092 return DW_ACCESS_private
;
12096 /* DWARF 3+ defines the default accessibility a different way. The same
12097 rules apply now for DW_TAG_inheritance as for the members and it only
12098 depends on the container kind. */
12100 if (die
->parent
->tag
== DW_TAG_class_type
)
12101 return DW_ACCESS_private
;
12103 return DW_ACCESS_public
;
12107 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12108 offset. If the attribute was not found return 0, otherwise return
12109 1. If it was found but could not properly be handled, set *OFFSET
12113 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
12116 struct attribute
*attr
;
12118 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
12123 /* Note that we do not check for a section offset first here.
12124 This is because DW_AT_data_member_location is new in DWARF 4,
12125 so if we see it, we can assume that a constant form is really
12126 a constant and not a section offset. */
12127 if (attr_form_is_constant (attr
))
12128 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
12129 else if (attr_form_is_section_offset (attr
))
12130 dwarf2_complex_location_expr_complaint ();
12131 else if (attr_form_is_block (attr
))
12132 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12134 dwarf2_complex_location_expr_complaint ();
12142 /* Add an aggregate field to the field list. */
12145 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
12146 struct dwarf2_cu
*cu
)
12148 struct objfile
*objfile
= cu
->objfile
;
12149 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12150 struct nextfield
*new_field
;
12151 struct attribute
*attr
;
12153 const char *fieldname
= "";
12155 /* Allocate a new field list entry and link it in. */
12156 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
12157 make_cleanup (xfree
, new_field
);
12158 memset (new_field
, 0, sizeof (struct nextfield
));
12160 if (die
->tag
== DW_TAG_inheritance
)
12162 new_field
->next
= fip
->baseclasses
;
12163 fip
->baseclasses
= new_field
;
12167 new_field
->next
= fip
->fields
;
12168 fip
->fields
= new_field
;
12172 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12174 new_field
->accessibility
= DW_UNSND (attr
);
12176 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
12177 if (new_field
->accessibility
!= DW_ACCESS_public
)
12178 fip
->non_public_fields
= 1;
12180 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12182 new_field
->virtuality
= DW_UNSND (attr
);
12184 new_field
->virtuality
= DW_VIRTUALITY_none
;
12186 fp
= &new_field
->field
;
12188 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
12192 /* Data member other than a C++ static data member. */
12194 /* Get type of field. */
12195 fp
->type
= die_type (die
, cu
);
12197 SET_FIELD_BITPOS (*fp
, 0);
12199 /* Get bit size of field (zero if none). */
12200 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
12203 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
12207 FIELD_BITSIZE (*fp
) = 0;
12210 /* Get bit offset of field. */
12211 if (handle_data_member_location (die
, cu
, &offset
))
12212 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12213 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
12216 if (gdbarch_bits_big_endian (gdbarch
))
12218 /* For big endian bits, the DW_AT_bit_offset gives the
12219 additional bit offset from the MSB of the containing
12220 anonymous object to the MSB of the field. We don't
12221 have to do anything special since we don't need to
12222 know the size of the anonymous object. */
12223 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
12227 /* For little endian bits, compute the bit offset to the
12228 MSB of the anonymous object, subtract off the number of
12229 bits from the MSB of the field to the MSB of the
12230 object, and then subtract off the number of bits of
12231 the field itself. The result is the bit offset of
12232 the LSB of the field. */
12233 int anonymous_size
;
12234 int bit_offset
= DW_UNSND (attr
);
12236 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12239 /* The size of the anonymous object containing
12240 the bit field is explicit, so use the
12241 indicated size (in bytes). */
12242 anonymous_size
= DW_UNSND (attr
);
12246 /* The size of the anonymous object containing
12247 the bit field must be inferred from the type
12248 attribute of the data member containing the
12250 anonymous_size
= TYPE_LENGTH (fp
->type
);
12252 SET_FIELD_BITPOS (*fp
,
12253 (FIELD_BITPOS (*fp
)
12254 + anonymous_size
* bits_per_byte
12255 - bit_offset
- FIELD_BITSIZE (*fp
)));
12259 /* Get name of field. */
12260 fieldname
= dwarf2_name (die
, cu
);
12261 if (fieldname
== NULL
)
12264 /* The name is already allocated along with this objfile, so we don't
12265 need to duplicate it for the type. */
12266 fp
->name
= fieldname
;
12268 /* Change accessibility for artificial fields (e.g. virtual table
12269 pointer or virtual base class pointer) to private. */
12270 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
12272 FIELD_ARTIFICIAL (*fp
) = 1;
12273 new_field
->accessibility
= DW_ACCESS_private
;
12274 fip
->non_public_fields
= 1;
12277 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
12279 /* C++ static member. */
12281 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12282 is a declaration, but all versions of G++ as of this writing
12283 (so through at least 3.2.1) incorrectly generate
12284 DW_TAG_variable tags. */
12286 const char *physname
;
12288 /* Get name of field. */
12289 fieldname
= dwarf2_name (die
, cu
);
12290 if (fieldname
== NULL
)
12293 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
12295 /* Only create a symbol if this is an external value.
12296 new_symbol checks this and puts the value in the global symbol
12297 table, which we want. If it is not external, new_symbol
12298 will try to put the value in cu->list_in_scope which is wrong. */
12299 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
12301 /* A static const member, not much different than an enum as far as
12302 we're concerned, except that we can support more types. */
12303 new_symbol (die
, NULL
, cu
);
12306 /* Get physical name. */
12307 physname
= dwarf2_physname (fieldname
, die
, cu
);
12309 /* The name is already allocated along with this objfile, so we don't
12310 need to duplicate it for the type. */
12311 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
12312 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12313 FIELD_NAME (*fp
) = fieldname
;
12315 else if (die
->tag
== DW_TAG_inheritance
)
12319 /* C++ base class field. */
12320 if (handle_data_member_location (die
, cu
, &offset
))
12321 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12322 FIELD_BITSIZE (*fp
) = 0;
12323 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12324 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
12325 fip
->nbaseclasses
++;
12329 /* Add a typedef defined in the scope of the FIP's class. */
12332 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
12333 struct dwarf2_cu
*cu
)
12335 struct objfile
*objfile
= cu
->objfile
;
12336 struct typedef_field_list
*new_field
;
12337 struct attribute
*attr
;
12338 struct typedef_field
*fp
;
12339 char *fieldname
= "";
12341 /* Allocate a new field list entry and link it in. */
12342 new_field
= xzalloc (sizeof (*new_field
));
12343 make_cleanup (xfree
, new_field
);
12345 gdb_assert (die
->tag
== DW_TAG_typedef
);
12347 fp
= &new_field
->field
;
12349 /* Get name of field. */
12350 fp
->name
= dwarf2_name (die
, cu
);
12351 if (fp
->name
== NULL
)
12354 fp
->type
= read_type_die (die
, cu
);
12356 new_field
->next
= fip
->typedef_field_list
;
12357 fip
->typedef_field_list
= new_field
;
12358 fip
->typedef_field_list_count
++;
12361 /* Create the vector of fields, and attach it to the type. */
12364 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
12365 struct dwarf2_cu
*cu
)
12367 int nfields
= fip
->nfields
;
12369 /* Record the field count, allocate space for the array of fields,
12370 and create blank accessibility bitfields if necessary. */
12371 TYPE_NFIELDS (type
) = nfields
;
12372 TYPE_FIELDS (type
) = (struct field
*)
12373 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
12374 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
12376 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
12378 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12380 TYPE_FIELD_PRIVATE_BITS (type
) =
12381 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12382 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
12384 TYPE_FIELD_PROTECTED_BITS (type
) =
12385 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12386 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
12388 TYPE_FIELD_IGNORE_BITS (type
) =
12389 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12390 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
12393 /* If the type has baseclasses, allocate and clear a bit vector for
12394 TYPE_FIELD_VIRTUAL_BITS. */
12395 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
12397 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
12398 unsigned char *pointer
;
12400 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12401 pointer
= TYPE_ALLOC (type
, num_bytes
);
12402 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
12403 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
12404 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
12407 /* Copy the saved-up fields into the field vector. Start from the head of
12408 the list, adding to the tail of the field array, so that they end up in
12409 the same order in the array in which they were added to the list. */
12410 while (nfields
-- > 0)
12412 struct nextfield
*fieldp
;
12416 fieldp
= fip
->fields
;
12417 fip
->fields
= fieldp
->next
;
12421 fieldp
= fip
->baseclasses
;
12422 fip
->baseclasses
= fieldp
->next
;
12425 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
12426 switch (fieldp
->accessibility
)
12428 case DW_ACCESS_private
:
12429 if (cu
->language
!= language_ada
)
12430 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
12433 case DW_ACCESS_protected
:
12434 if (cu
->language
!= language_ada
)
12435 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
12438 case DW_ACCESS_public
:
12442 /* Unknown accessibility. Complain and treat it as public. */
12444 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
12445 fieldp
->accessibility
);
12449 if (nfields
< fip
->nbaseclasses
)
12451 switch (fieldp
->virtuality
)
12453 case DW_VIRTUALITY_virtual
:
12454 case DW_VIRTUALITY_pure_virtual
:
12455 if (cu
->language
== language_ada
)
12456 error (_("unexpected virtuality in component of Ada type"));
12457 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
12464 /* Return true if this member function is a constructor, false
12468 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
12470 const char *fieldname
;
12471 const char *typename
;
12474 if (die
->parent
== NULL
)
12477 if (die
->parent
->tag
!= DW_TAG_structure_type
12478 && die
->parent
->tag
!= DW_TAG_union_type
12479 && die
->parent
->tag
!= DW_TAG_class_type
)
12482 fieldname
= dwarf2_name (die
, cu
);
12483 typename
= dwarf2_name (die
->parent
, cu
);
12484 if (fieldname
== NULL
|| typename
== NULL
)
12487 len
= strlen (fieldname
);
12488 return (strncmp (fieldname
, typename
, len
) == 0
12489 && (typename
[len
] == '\0' || typename
[len
] == '<'));
12492 /* Add a member function to the proper fieldlist. */
12495 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
12496 struct type
*type
, struct dwarf2_cu
*cu
)
12498 struct objfile
*objfile
= cu
->objfile
;
12499 struct attribute
*attr
;
12500 struct fnfieldlist
*flp
;
12502 struct fn_field
*fnp
;
12503 const char *fieldname
;
12504 struct nextfnfield
*new_fnfield
;
12505 struct type
*this_type
;
12506 enum dwarf_access_attribute accessibility
;
12508 if (cu
->language
== language_ada
)
12509 error (_("unexpected member function in Ada type"));
12511 /* Get name of member function. */
12512 fieldname
= dwarf2_name (die
, cu
);
12513 if (fieldname
== NULL
)
12516 /* Look up member function name in fieldlist. */
12517 for (i
= 0; i
< fip
->nfnfields
; i
++)
12519 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
12523 /* Create new list element if necessary. */
12524 if (i
< fip
->nfnfields
)
12525 flp
= &fip
->fnfieldlists
[i
];
12528 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
12530 fip
->fnfieldlists
= (struct fnfieldlist
*)
12531 xrealloc (fip
->fnfieldlists
,
12532 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
12533 * sizeof (struct fnfieldlist
));
12534 if (fip
->nfnfields
== 0)
12535 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
12537 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
12538 flp
->name
= fieldname
;
12541 i
= fip
->nfnfields
++;
12544 /* Create a new member function field and chain it to the field list
12546 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
12547 make_cleanup (xfree
, new_fnfield
);
12548 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
12549 new_fnfield
->next
= flp
->head
;
12550 flp
->head
= new_fnfield
;
12553 /* Fill in the member function field info. */
12554 fnp
= &new_fnfield
->fnfield
;
12556 /* Delay processing of the physname until later. */
12557 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
12559 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
12564 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
12565 fnp
->physname
= physname
? physname
: "";
12568 fnp
->type
= alloc_type (objfile
);
12569 this_type
= read_type_die (die
, cu
);
12570 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
12572 int nparams
= TYPE_NFIELDS (this_type
);
12574 /* TYPE is the domain of this method, and THIS_TYPE is the type
12575 of the method itself (TYPE_CODE_METHOD). */
12576 smash_to_method_type (fnp
->type
, type
,
12577 TYPE_TARGET_TYPE (this_type
),
12578 TYPE_FIELDS (this_type
),
12579 TYPE_NFIELDS (this_type
),
12580 TYPE_VARARGS (this_type
));
12582 /* Handle static member functions.
12583 Dwarf2 has no clean way to discern C++ static and non-static
12584 member functions. G++ helps GDB by marking the first
12585 parameter for non-static member functions (which is the this
12586 pointer) as artificial. We obtain this information from
12587 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12588 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
12589 fnp
->voffset
= VOFFSET_STATIC
;
12592 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
12593 dwarf2_full_name (fieldname
, die
, cu
));
12595 /* Get fcontext from DW_AT_containing_type if present. */
12596 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
12597 fnp
->fcontext
= die_containing_type (die
, cu
);
12599 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12600 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12602 /* Get accessibility. */
12603 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12605 accessibility
= DW_UNSND (attr
);
12607 accessibility
= dwarf2_default_access_attribute (die
, cu
);
12608 switch (accessibility
)
12610 case DW_ACCESS_private
:
12611 fnp
->is_private
= 1;
12613 case DW_ACCESS_protected
:
12614 fnp
->is_protected
= 1;
12618 /* Check for artificial methods. */
12619 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
12620 if (attr
&& DW_UNSND (attr
) != 0)
12621 fnp
->is_artificial
= 1;
12623 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
12625 /* Get index in virtual function table if it is a virtual member
12626 function. For older versions of GCC, this is an offset in the
12627 appropriate virtual table, as specified by DW_AT_containing_type.
12628 For everyone else, it is an expression to be evaluated relative
12629 to the object address. */
12631 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
12634 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
12636 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
12638 /* Old-style GCC. */
12639 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
12641 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12642 || (DW_BLOCK (attr
)->size
> 1
12643 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
12644 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
12646 struct dwarf_block blk
;
12649 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12651 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
12652 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
12653 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12654 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
12655 dwarf2_complex_location_expr_complaint ();
12657 fnp
->voffset
/= cu
->header
.addr_size
;
12661 dwarf2_complex_location_expr_complaint ();
12663 if (!fnp
->fcontext
)
12664 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
12666 else if (attr_form_is_section_offset (attr
))
12668 dwarf2_complex_location_expr_complaint ();
12672 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12678 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12679 if (attr
&& DW_UNSND (attr
))
12681 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12682 complaint (&symfile_complaints
,
12683 _("Member function \"%s\" (offset %d) is virtual "
12684 "but the vtable offset is not specified"),
12685 fieldname
, die
->offset
.sect_off
);
12686 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12687 TYPE_CPLUS_DYNAMIC (type
) = 1;
12692 /* Create the vector of member function fields, and attach it to the type. */
12695 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
12696 struct dwarf2_cu
*cu
)
12698 struct fnfieldlist
*flp
;
12701 if (cu
->language
== language_ada
)
12702 error (_("unexpected member functions in Ada type"));
12704 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12705 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
12706 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
12708 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
12710 struct nextfnfield
*nfp
= flp
->head
;
12711 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
12714 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
12715 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
12716 fn_flp
->fn_fields
= (struct fn_field
*)
12717 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
12718 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
12719 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
12722 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
12725 /* Returns non-zero if NAME is the name of a vtable member in CU's
12726 language, zero otherwise. */
12728 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
12730 static const char vptr
[] = "_vptr";
12731 static const char vtable
[] = "vtable";
12733 /* Look for the C++ and Java forms of the vtable. */
12734 if ((cu
->language
== language_java
12735 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
12736 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
12737 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
12743 /* GCC outputs unnamed structures that are really pointers to member
12744 functions, with the ABI-specified layout. If TYPE describes
12745 such a structure, smash it into a member function type.
12747 GCC shouldn't do this; it should just output pointer to member DIEs.
12748 This is GCC PR debug/28767. */
12751 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
12753 struct type
*pfn_type
, *domain_type
, *new_type
;
12755 /* Check for a structure with no name and two children. */
12756 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
12759 /* Check for __pfn and __delta members. */
12760 if (TYPE_FIELD_NAME (type
, 0) == NULL
12761 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
12762 || TYPE_FIELD_NAME (type
, 1) == NULL
12763 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
12766 /* Find the type of the method. */
12767 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
12768 if (pfn_type
== NULL
12769 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
12770 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
12773 /* Look for the "this" argument. */
12774 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
12775 if (TYPE_NFIELDS (pfn_type
) == 0
12776 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
12777 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
12780 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
12781 new_type
= alloc_type (objfile
);
12782 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
12783 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
12784 TYPE_VARARGS (pfn_type
));
12785 smash_to_methodptr_type (type
, new_type
);
12788 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
12792 producer_is_icc (struct dwarf2_cu
*cu
)
12794 if (!cu
->checked_producer
)
12795 check_producer (cu
);
12797 return cu
->producer_is_icc
;
12800 /* Called when we find the DIE that starts a structure or union scope
12801 (definition) to create a type for the structure or union. Fill in
12802 the type's name and general properties; the members will not be
12803 processed until process_structure_scope.
12805 NOTE: we need to call these functions regardless of whether or not the
12806 DIE has a DW_AT_name attribute, since it might be an anonymous
12807 structure or union. This gets the type entered into our set of
12808 user defined types.
12810 However, if the structure is incomplete (an opaque struct/union)
12811 then suppress creating a symbol table entry for it since gdb only
12812 wants to find the one with the complete definition. Note that if
12813 it is complete, we just call new_symbol, which does it's own
12814 checking about whether the struct/union is anonymous or not (and
12815 suppresses creating a symbol table entry itself). */
12817 static struct type
*
12818 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12820 struct objfile
*objfile
= cu
->objfile
;
12822 struct attribute
*attr
;
12825 /* If the definition of this type lives in .debug_types, read that type.
12826 Don't follow DW_AT_specification though, that will take us back up
12827 the chain and we want to go down. */
12828 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
12831 type
= get_DW_AT_signature_type (die
, attr
, cu
);
12833 /* The type's CU may not be the same as CU.
12834 Ensure TYPE is recorded with CU in die_type_hash. */
12835 return set_die_type (die
, type
, cu
);
12838 type
= alloc_type (objfile
);
12839 INIT_CPLUS_SPECIFIC (type
);
12841 name
= dwarf2_name (die
, cu
);
12844 if (cu
->language
== language_cplus
12845 || cu
->language
== language_java
)
12847 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
12849 /* dwarf2_full_name might have already finished building the DIE's
12850 type. If so, there is no need to continue. */
12851 if (get_die_type (die
, cu
) != NULL
)
12852 return get_die_type (die
, cu
);
12854 TYPE_TAG_NAME (type
) = full_name
;
12855 if (die
->tag
== DW_TAG_structure_type
12856 || die
->tag
== DW_TAG_class_type
)
12857 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
12861 /* The name is already allocated along with this objfile, so
12862 we don't need to duplicate it for the type. */
12863 TYPE_TAG_NAME (type
) = name
;
12864 if (die
->tag
== DW_TAG_class_type
)
12865 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
12869 if (die
->tag
== DW_TAG_structure_type
)
12871 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
12873 else if (die
->tag
== DW_TAG_union_type
)
12875 TYPE_CODE (type
) = TYPE_CODE_UNION
;
12879 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
12882 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
12883 TYPE_DECLARED_CLASS (type
) = 1;
12885 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12888 TYPE_LENGTH (type
) = DW_UNSND (attr
);
12892 TYPE_LENGTH (type
) = 0;
12895 if (producer_is_icc (cu
))
12897 /* ICC does not output the required DW_AT_declaration
12898 on incomplete types, but gives them a size of zero. */
12901 TYPE_STUB_SUPPORTED (type
) = 1;
12903 if (die_is_declaration (die
, cu
))
12904 TYPE_STUB (type
) = 1;
12905 else if (attr
== NULL
&& die
->child
== NULL
12906 && producer_is_realview (cu
->producer
))
12907 /* RealView does not output the required DW_AT_declaration
12908 on incomplete types. */
12909 TYPE_STUB (type
) = 1;
12911 /* We need to add the type field to the die immediately so we don't
12912 infinitely recurse when dealing with pointers to the structure
12913 type within the structure itself. */
12914 set_die_type (die
, type
, cu
);
12916 /* set_die_type should be already done. */
12917 set_descriptive_type (type
, die
, cu
);
12922 /* Finish creating a structure or union type, including filling in
12923 its members and creating a symbol for it. */
12926 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
12928 struct objfile
*objfile
= cu
->objfile
;
12929 struct die_info
*child_die
= die
->child
;
12932 type
= get_die_type (die
, cu
);
12934 type
= read_structure_type (die
, cu
);
12936 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
12938 struct field_info fi
;
12939 struct die_info
*child_die
;
12940 VEC (symbolp
) *template_args
= NULL
;
12941 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
12943 memset (&fi
, 0, sizeof (struct field_info
));
12945 child_die
= die
->child
;
12947 while (child_die
&& child_die
->tag
)
12949 if (child_die
->tag
== DW_TAG_member
12950 || child_die
->tag
== DW_TAG_variable
)
12952 /* NOTE: carlton/2002-11-05: A C++ static data member
12953 should be a DW_TAG_member that is a declaration, but
12954 all versions of G++ as of this writing (so through at
12955 least 3.2.1) incorrectly generate DW_TAG_variable
12956 tags for them instead. */
12957 dwarf2_add_field (&fi
, child_die
, cu
);
12959 else if (child_die
->tag
== DW_TAG_subprogram
)
12961 /* C++ member function. */
12962 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
12964 else if (child_die
->tag
== DW_TAG_inheritance
)
12966 /* C++ base class field. */
12967 dwarf2_add_field (&fi
, child_die
, cu
);
12969 else if (child_die
->tag
== DW_TAG_typedef
)
12970 dwarf2_add_typedef (&fi
, child_die
, cu
);
12971 else if (child_die
->tag
== DW_TAG_template_type_param
12972 || child_die
->tag
== DW_TAG_template_value_param
)
12974 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
12977 VEC_safe_push (symbolp
, template_args
, arg
);
12980 child_die
= sibling_die (child_die
);
12983 /* Attach template arguments to type. */
12984 if (! VEC_empty (symbolp
, template_args
))
12986 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12987 TYPE_N_TEMPLATE_ARGUMENTS (type
)
12988 = VEC_length (symbolp
, template_args
);
12989 TYPE_TEMPLATE_ARGUMENTS (type
)
12990 = obstack_alloc (&objfile
->objfile_obstack
,
12991 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
12992 * sizeof (struct symbol
*)));
12993 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
12994 VEC_address (symbolp
, template_args
),
12995 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
12996 * sizeof (struct symbol
*)));
12997 VEC_free (symbolp
, template_args
);
13000 /* Attach fields and member functions to the type. */
13002 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
13005 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
13007 /* Get the type which refers to the base class (possibly this
13008 class itself) which contains the vtable pointer for the current
13009 class from the DW_AT_containing_type attribute. This use of
13010 DW_AT_containing_type is a GNU extension. */
13012 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
13014 struct type
*t
= die_containing_type (die
, cu
);
13016 TYPE_VPTR_BASETYPE (type
) = t
;
13021 /* Our own class provides vtbl ptr. */
13022 for (i
= TYPE_NFIELDS (t
) - 1;
13023 i
>= TYPE_N_BASECLASSES (t
);
13026 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
13028 if (is_vtable_name (fieldname
, cu
))
13030 TYPE_VPTR_FIELDNO (type
) = i
;
13035 /* Complain if virtual function table field not found. */
13036 if (i
< TYPE_N_BASECLASSES (t
))
13037 complaint (&symfile_complaints
,
13038 _("virtual function table pointer "
13039 "not found when defining class '%s'"),
13040 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
13045 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
13048 else if (cu
->producer
13049 && strncmp (cu
->producer
,
13050 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
13052 /* The IBM XLC compiler does not provide direct indication
13053 of the containing type, but the vtable pointer is
13054 always named __vfp. */
13058 for (i
= TYPE_NFIELDS (type
) - 1;
13059 i
>= TYPE_N_BASECLASSES (type
);
13062 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
13064 TYPE_VPTR_FIELDNO (type
) = i
;
13065 TYPE_VPTR_BASETYPE (type
) = type
;
13072 /* Copy fi.typedef_field_list linked list elements content into the
13073 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13074 if (fi
.typedef_field_list
)
13076 int i
= fi
.typedef_field_list_count
;
13078 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13079 TYPE_TYPEDEF_FIELD_ARRAY (type
)
13080 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
13081 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
13083 /* Reverse the list order to keep the debug info elements order. */
13086 struct typedef_field
*dest
, *src
;
13088 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
13089 src
= &fi
.typedef_field_list
->field
;
13090 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
13095 do_cleanups (back_to
);
13097 if (HAVE_CPLUS_STRUCT (type
))
13098 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
13101 quirk_gcc_member_function_pointer (type
, objfile
);
13103 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13104 snapshots) has been known to create a die giving a declaration
13105 for a class that has, as a child, a die giving a definition for a
13106 nested class. So we have to process our children even if the
13107 current die is a declaration. Normally, of course, a declaration
13108 won't have any children at all. */
13110 while (child_die
!= NULL
&& child_die
->tag
)
13112 if (child_die
->tag
== DW_TAG_member
13113 || child_die
->tag
== DW_TAG_variable
13114 || child_die
->tag
== DW_TAG_inheritance
13115 || child_die
->tag
== DW_TAG_template_value_param
13116 || child_die
->tag
== DW_TAG_template_type_param
)
13121 process_die (child_die
, cu
);
13123 child_die
= sibling_die (child_die
);
13126 /* Do not consider external references. According to the DWARF standard,
13127 these DIEs are identified by the fact that they have no byte_size
13128 attribute, and a declaration attribute. */
13129 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
13130 || !die_is_declaration (die
, cu
))
13131 new_symbol (die
, type
, cu
);
13134 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13135 update TYPE using some information only available in DIE's children. */
13138 update_enumeration_type_from_children (struct die_info
*die
,
13140 struct dwarf2_cu
*cu
)
13142 struct obstack obstack
;
13143 struct die_info
*child_die
= die
->child
;
13144 int unsigned_enum
= 1;
13147 struct cleanup
*old_chain
;
13149 obstack_init (&obstack
);
13150 old_chain
= make_cleanup_obstack_free (&obstack
);
13152 while (child_die
!= NULL
&& child_die
->tag
)
13154 struct attribute
*attr
;
13156 const gdb_byte
*bytes
;
13157 struct dwarf2_locexpr_baton
*baton
;
13159 if (child_die
->tag
!= DW_TAG_enumerator
)
13162 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
13166 name
= dwarf2_name (child_die
, cu
);
13168 name
= "<anonymous enumerator>";
13170 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
13171 &value
, &bytes
, &baton
);
13177 else if ((mask
& value
) != 0)
13182 /* If we already know that the enum type is neither unsigned, nor
13183 a flag type, no need to look at the rest of the enumerates. */
13184 if (!unsigned_enum
&& !flag_enum
)
13186 child_die
= sibling_die (child_die
);
13190 TYPE_UNSIGNED (type
) = 1;
13192 TYPE_FLAG_ENUM (type
) = 1;
13194 do_cleanups (old_chain
);
13197 /* Given a DW_AT_enumeration_type die, set its type. We do not
13198 complete the type's fields yet, or create any symbols. */
13200 static struct type
*
13201 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13203 struct objfile
*objfile
= cu
->objfile
;
13205 struct attribute
*attr
;
13208 /* If the definition of this type lives in .debug_types, read that type.
13209 Don't follow DW_AT_specification though, that will take us back up
13210 the chain and we want to go down. */
13211 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13214 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13216 /* The type's CU may not be the same as CU.
13217 Ensure TYPE is recorded with CU in die_type_hash. */
13218 return set_die_type (die
, type
, cu
);
13221 type
= alloc_type (objfile
);
13223 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
13224 name
= dwarf2_full_name (NULL
, die
, cu
);
13226 TYPE_TAG_NAME (type
) = name
;
13228 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13231 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13235 TYPE_LENGTH (type
) = 0;
13238 /* The enumeration DIE can be incomplete. In Ada, any type can be
13239 declared as private in the package spec, and then defined only
13240 inside the package body. Such types are known as Taft Amendment
13241 Types. When another package uses such a type, an incomplete DIE
13242 may be generated by the compiler. */
13243 if (die_is_declaration (die
, cu
))
13244 TYPE_STUB (type
) = 1;
13246 /* Finish the creation of this type by using the enum's children. */
13247 update_enumeration_type_from_children (die
, type
, cu
);
13249 return set_die_type (die
, type
, cu
);
13252 /* Given a pointer to a die which begins an enumeration, process all
13253 the dies that define the members of the enumeration, and create the
13254 symbol for the enumeration type.
13256 NOTE: We reverse the order of the element list. */
13259 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13261 struct type
*this_type
;
13263 this_type
= get_die_type (die
, cu
);
13264 if (this_type
== NULL
)
13265 this_type
= read_enumeration_type (die
, cu
);
13267 if (die
->child
!= NULL
)
13269 struct die_info
*child_die
;
13270 struct symbol
*sym
;
13271 struct field
*fields
= NULL
;
13272 int num_fields
= 0;
13275 child_die
= die
->child
;
13276 while (child_die
&& child_die
->tag
)
13278 if (child_die
->tag
!= DW_TAG_enumerator
)
13280 process_die (child_die
, cu
);
13284 name
= dwarf2_name (child_die
, cu
);
13287 sym
= new_symbol (child_die
, this_type
, cu
);
13289 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
13291 fields
= (struct field
*)
13293 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
13294 * sizeof (struct field
));
13297 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
13298 FIELD_TYPE (fields
[num_fields
]) = NULL
;
13299 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
13300 FIELD_BITSIZE (fields
[num_fields
]) = 0;
13306 child_die
= sibling_die (child_die
);
13311 TYPE_NFIELDS (this_type
) = num_fields
;
13312 TYPE_FIELDS (this_type
) = (struct field
*)
13313 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
13314 memcpy (TYPE_FIELDS (this_type
), fields
,
13315 sizeof (struct field
) * num_fields
);
13320 /* If we are reading an enum from a .debug_types unit, and the enum
13321 is a declaration, and the enum is not the signatured type in the
13322 unit, then we do not want to add a symbol for it. Adding a
13323 symbol would in some cases obscure the true definition of the
13324 enum, giving users an incomplete type when the definition is
13325 actually available. Note that we do not want to do this for all
13326 enums which are just declarations, because C++0x allows forward
13327 enum declarations. */
13328 if (cu
->per_cu
->is_debug_types
13329 && die_is_declaration (die
, cu
))
13331 struct signatured_type
*sig_type
;
13333 sig_type
= (struct signatured_type
*) cu
->per_cu
;
13334 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
13335 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
13339 new_symbol (die
, this_type
, cu
);
13342 /* Extract all information from a DW_TAG_array_type DIE and put it in
13343 the DIE's type field. For now, this only handles one dimensional
13346 static struct type
*
13347 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13349 struct objfile
*objfile
= cu
->objfile
;
13350 struct die_info
*child_die
;
13352 struct type
*element_type
, *range_type
, *index_type
;
13353 struct type
**range_types
= NULL
;
13354 struct attribute
*attr
;
13356 struct cleanup
*back_to
;
13358 unsigned int bit_stride
= 0;
13360 element_type
= die_type (die
, cu
);
13362 /* The die_type call above may have already set the type for this DIE. */
13363 type
= get_die_type (die
, cu
);
13367 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
13369 bit_stride
= DW_UNSND (attr
) * 8;
13371 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
13373 bit_stride
= DW_UNSND (attr
);
13375 /* Irix 6.2 native cc creates array types without children for
13376 arrays with unspecified length. */
13377 if (die
->child
== NULL
)
13379 index_type
= objfile_type (objfile
)->builtin_int
;
13380 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
13381 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
13383 return set_die_type (die
, type
, cu
);
13386 back_to
= make_cleanup (null_cleanup
, NULL
);
13387 child_die
= die
->child
;
13388 while (child_die
&& child_die
->tag
)
13390 if (child_die
->tag
== DW_TAG_subrange_type
)
13392 struct type
*child_type
= read_type_die (child_die
, cu
);
13394 if (child_type
!= NULL
)
13396 /* The range type was succesfully read. Save it for the
13397 array type creation. */
13398 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
13400 range_types
= (struct type
**)
13401 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
13402 * sizeof (struct type
*));
13404 make_cleanup (free_current_contents
, &range_types
);
13406 range_types
[ndim
++] = child_type
;
13409 child_die
= sibling_die (child_die
);
13412 /* Dwarf2 dimensions are output from left to right, create the
13413 necessary array types in backwards order. */
13415 type
= element_type
;
13417 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
13422 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
13428 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
13432 /* Understand Dwarf2 support for vector types (like they occur on
13433 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13434 array type. This is not part of the Dwarf2/3 standard yet, but a
13435 custom vendor extension. The main difference between a regular
13436 array and the vector variant is that vectors are passed by value
13438 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
13440 make_vector_type (type
);
13442 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13443 implementation may choose to implement triple vectors using this
13445 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13448 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
13449 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13451 complaint (&symfile_complaints
,
13452 _("DW_AT_byte_size for array type smaller "
13453 "than the total size of elements"));
13456 name
= dwarf2_name (die
, cu
);
13458 TYPE_NAME (type
) = name
;
13460 /* Install the type in the die. */
13461 set_die_type (die
, type
, cu
);
13463 /* set_die_type should be already done. */
13464 set_descriptive_type (type
, die
, cu
);
13466 do_cleanups (back_to
);
13471 static enum dwarf_array_dim_ordering
13472 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
13474 struct attribute
*attr
;
13476 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
13478 if (attr
) return DW_SND (attr
);
13480 /* GNU F77 is a special case, as at 08/2004 array type info is the
13481 opposite order to the dwarf2 specification, but data is still
13482 laid out as per normal fortran.
13484 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13485 version checking. */
13487 if (cu
->language
== language_fortran
13488 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
13490 return DW_ORD_row_major
;
13493 switch (cu
->language_defn
->la_array_ordering
)
13495 case array_column_major
:
13496 return DW_ORD_col_major
;
13497 case array_row_major
:
13499 return DW_ORD_row_major
;
13503 /* Extract all information from a DW_TAG_set_type DIE and put it in
13504 the DIE's type field. */
13506 static struct type
*
13507 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13509 struct type
*domain_type
, *set_type
;
13510 struct attribute
*attr
;
13512 domain_type
= die_type (die
, cu
);
13514 /* The die_type call above may have already set the type for this DIE. */
13515 set_type
= get_die_type (die
, cu
);
13519 set_type
= create_set_type (NULL
, domain_type
);
13521 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13523 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
13525 return set_die_type (die
, set_type
, cu
);
13528 /* A helper for read_common_block that creates a locexpr baton.
13529 SYM is the symbol which we are marking as computed.
13530 COMMON_DIE is the DIE for the common block.
13531 COMMON_LOC is the location expression attribute for the common
13533 MEMBER_LOC is the location expression attribute for the particular
13534 member of the common block that we are processing.
13535 CU is the CU from which the above come. */
13538 mark_common_block_symbol_computed (struct symbol
*sym
,
13539 struct die_info
*common_die
,
13540 struct attribute
*common_loc
,
13541 struct attribute
*member_loc
,
13542 struct dwarf2_cu
*cu
)
13544 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13545 struct dwarf2_locexpr_baton
*baton
;
13547 unsigned int cu_off
;
13548 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
13549 LONGEST offset
= 0;
13551 gdb_assert (common_loc
&& member_loc
);
13552 gdb_assert (attr_form_is_block (common_loc
));
13553 gdb_assert (attr_form_is_block (member_loc
)
13554 || attr_form_is_constant (member_loc
));
13556 baton
= obstack_alloc (&objfile
->objfile_obstack
,
13557 sizeof (struct dwarf2_locexpr_baton
));
13558 baton
->per_cu
= cu
->per_cu
;
13559 gdb_assert (baton
->per_cu
);
13561 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13563 if (attr_form_is_constant (member_loc
))
13565 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
13566 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
13569 baton
->size
+= DW_BLOCK (member_loc
)->size
;
13571 ptr
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
13574 *ptr
++ = DW_OP_call4
;
13575 cu_off
= common_die
->offset
.sect_off
- cu
->per_cu
->offset
.sect_off
;
13576 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
13579 if (attr_form_is_constant (member_loc
))
13581 *ptr
++ = DW_OP_addr
;
13582 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
13583 ptr
+= cu
->header
.addr_size
;
13587 /* We have to copy the data here, because DW_OP_call4 will only
13588 use a DW_AT_location attribute. */
13589 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
13590 ptr
+= DW_BLOCK (member_loc
)->size
;
13593 *ptr
++ = DW_OP_plus
;
13594 gdb_assert (ptr
- baton
->data
== baton
->size
);
13596 SYMBOL_LOCATION_BATON (sym
) = baton
;
13597 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
13600 /* Create appropriate locally-scoped variables for all the
13601 DW_TAG_common_block entries. Also create a struct common_block
13602 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13603 is used to sepate the common blocks name namespace from regular
13607 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
13609 struct attribute
*attr
;
13611 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13614 /* Support the .debug_loc offsets. */
13615 if (attr_form_is_block (attr
))
13619 else if (attr_form_is_section_offset (attr
))
13621 dwarf2_complex_location_expr_complaint ();
13626 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13627 "common block member");
13632 if (die
->child
!= NULL
)
13634 struct objfile
*objfile
= cu
->objfile
;
13635 struct die_info
*child_die
;
13636 size_t n_entries
= 0, size
;
13637 struct common_block
*common_block
;
13638 struct symbol
*sym
;
13640 for (child_die
= die
->child
;
13641 child_die
&& child_die
->tag
;
13642 child_die
= sibling_die (child_die
))
13645 size
= (sizeof (struct common_block
)
13646 + (n_entries
- 1) * sizeof (struct symbol
*));
13647 common_block
= obstack_alloc (&objfile
->objfile_obstack
, size
);
13648 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
13649 common_block
->n_entries
= 0;
13651 for (child_die
= die
->child
;
13652 child_die
&& child_die
->tag
;
13653 child_die
= sibling_die (child_die
))
13655 /* Create the symbol in the DW_TAG_common_block block in the current
13657 sym
= new_symbol (child_die
, NULL
, cu
);
13660 struct attribute
*member_loc
;
13662 common_block
->contents
[common_block
->n_entries
++] = sym
;
13664 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
13668 /* GDB has handled this for a long time, but it is
13669 not specified by DWARF. It seems to have been
13670 emitted by gfortran at least as recently as:
13671 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
13672 complaint (&symfile_complaints
,
13673 _("Variable in common block has "
13674 "DW_AT_data_member_location "
13675 "- DIE at 0x%x [in module %s]"),
13676 child_die
->offset
.sect_off
,
13677 objfile_name (cu
->objfile
));
13679 if (attr_form_is_section_offset (member_loc
))
13680 dwarf2_complex_location_expr_complaint ();
13681 else if (attr_form_is_constant (member_loc
)
13682 || attr_form_is_block (member_loc
))
13685 mark_common_block_symbol_computed (sym
, die
, attr
,
13689 dwarf2_complex_location_expr_complaint ();
13694 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
13695 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
13699 /* Create a type for a C++ namespace. */
13701 static struct type
*
13702 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13704 struct objfile
*objfile
= cu
->objfile
;
13705 const char *previous_prefix
, *name
;
13709 /* For extensions, reuse the type of the original namespace. */
13710 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
13712 struct die_info
*ext_die
;
13713 struct dwarf2_cu
*ext_cu
= cu
;
13715 ext_die
= dwarf2_extension (die
, &ext_cu
);
13716 type
= read_type_die (ext_die
, ext_cu
);
13718 /* EXT_CU may not be the same as CU.
13719 Ensure TYPE is recorded with CU in die_type_hash. */
13720 return set_die_type (die
, type
, cu
);
13723 name
= namespace_name (die
, &is_anonymous
, cu
);
13725 /* Now build the name of the current namespace. */
13727 previous_prefix
= determine_prefix (die
, cu
);
13728 if (previous_prefix
[0] != '\0')
13729 name
= typename_concat (&objfile
->objfile_obstack
,
13730 previous_prefix
, name
, 0, cu
);
13732 /* Create the type. */
13733 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
13735 TYPE_NAME (type
) = name
;
13736 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
13738 return set_die_type (die
, type
, cu
);
13741 /* Read a C++ namespace. */
13744 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
13746 struct objfile
*objfile
= cu
->objfile
;
13749 /* Add a symbol associated to this if we haven't seen the namespace
13750 before. Also, add a using directive if it's an anonymous
13753 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
13757 type
= read_type_die (die
, cu
);
13758 new_symbol (die
, type
, cu
);
13760 namespace_name (die
, &is_anonymous
, cu
);
13763 const char *previous_prefix
= determine_prefix (die
, cu
);
13765 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
13766 NULL
, NULL
, 0, &objfile
->objfile_obstack
);
13770 if (die
->child
!= NULL
)
13772 struct die_info
*child_die
= die
->child
;
13774 while (child_die
&& child_die
->tag
)
13776 process_die (child_die
, cu
);
13777 child_die
= sibling_die (child_die
);
13782 /* Read a Fortran module as type. This DIE can be only a declaration used for
13783 imported module. Still we need that type as local Fortran "use ... only"
13784 declaration imports depend on the created type in determine_prefix. */
13786 static struct type
*
13787 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13789 struct objfile
*objfile
= cu
->objfile
;
13790 const char *module_name
;
13793 module_name
= dwarf2_name (die
, cu
);
13795 complaint (&symfile_complaints
,
13796 _("DW_TAG_module has no name, offset 0x%x"),
13797 die
->offset
.sect_off
);
13798 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
13800 /* determine_prefix uses TYPE_TAG_NAME. */
13801 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
13803 return set_die_type (die
, type
, cu
);
13806 /* Read a Fortran module. */
13809 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
13811 struct die_info
*child_die
= die
->child
;
13814 type
= read_type_die (die
, cu
);
13815 new_symbol (die
, type
, cu
);
13817 while (child_die
&& child_die
->tag
)
13819 process_die (child_die
, cu
);
13820 child_die
= sibling_die (child_die
);
13824 /* Return the name of the namespace represented by DIE. Set
13825 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
13828 static const char *
13829 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
13831 struct die_info
*current_die
;
13832 const char *name
= NULL
;
13834 /* Loop through the extensions until we find a name. */
13836 for (current_die
= die
;
13837 current_die
!= NULL
;
13838 current_die
= dwarf2_extension (die
, &cu
))
13840 name
= dwarf2_name (current_die
, cu
);
13845 /* Is it an anonymous namespace? */
13847 *is_anonymous
= (name
== NULL
);
13849 name
= CP_ANONYMOUS_NAMESPACE_STR
;
13854 /* Extract all information from a DW_TAG_pointer_type DIE and add to
13855 the user defined type vector. */
13857 static struct type
*
13858 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13860 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
13861 struct comp_unit_head
*cu_header
= &cu
->header
;
13863 struct attribute
*attr_byte_size
;
13864 struct attribute
*attr_address_class
;
13865 int byte_size
, addr_class
;
13866 struct type
*target_type
;
13868 target_type
= die_type (die
, cu
);
13870 /* The die_type call above may have already set the type for this DIE. */
13871 type
= get_die_type (die
, cu
);
13875 type
= lookup_pointer_type (target_type
);
13877 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13878 if (attr_byte_size
)
13879 byte_size
= DW_UNSND (attr_byte_size
);
13881 byte_size
= cu_header
->addr_size
;
13883 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
13884 if (attr_address_class
)
13885 addr_class
= DW_UNSND (attr_address_class
);
13887 addr_class
= DW_ADDR_none
;
13889 /* If the pointer size or address class is different than the
13890 default, create a type variant marked as such and set the
13891 length accordingly. */
13892 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
13894 if (gdbarch_address_class_type_flags_p (gdbarch
))
13898 type_flags
= gdbarch_address_class_type_flags
13899 (gdbarch
, byte_size
, addr_class
);
13900 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
13902 type
= make_type_with_address_space (type
, type_flags
);
13904 else if (TYPE_LENGTH (type
) != byte_size
)
13906 complaint (&symfile_complaints
,
13907 _("invalid pointer size %d"), byte_size
);
13911 /* Should we also complain about unhandled address classes? */
13915 TYPE_LENGTH (type
) = byte_size
;
13916 return set_die_type (die
, type
, cu
);
13919 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
13920 the user defined type vector. */
13922 static struct type
*
13923 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13926 struct type
*to_type
;
13927 struct type
*domain
;
13929 to_type
= die_type (die
, cu
);
13930 domain
= die_containing_type (die
, cu
);
13932 /* The calls above may have already set the type for this DIE. */
13933 type
= get_die_type (die
, cu
);
13937 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
13938 type
= lookup_methodptr_type (to_type
);
13939 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
13941 struct type
*new_type
= alloc_type (cu
->objfile
);
13943 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
13944 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
13945 TYPE_VARARGS (to_type
));
13946 type
= lookup_methodptr_type (new_type
);
13949 type
= lookup_memberptr_type (to_type
, domain
);
13951 return set_die_type (die
, type
, cu
);
13954 /* Extract all information from a DW_TAG_reference_type DIE and add to
13955 the user defined type vector. */
13957 static struct type
*
13958 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13960 struct comp_unit_head
*cu_header
= &cu
->header
;
13961 struct type
*type
, *target_type
;
13962 struct attribute
*attr
;
13964 target_type
= die_type (die
, cu
);
13966 /* The die_type call above may have already set the type for this DIE. */
13967 type
= get_die_type (die
, cu
);
13971 type
= lookup_reference_type (target_type
);
13972 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13975 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13979 TYPE_LENGTH (type
) = cu_header
->addr_size
;
13981 return set_die_type (die
, type
, cu
);
13984 static struct type
*
13985 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13987 struct type
*base_type
, *cv_type
;
13989 base_type
= die_type (die
, cu
);
13991 /* The die_type call above may have already set the type for this DIE. */
13992 cv_type
= get_die_type (die
, cu
);
13996 /* In case the const qualifier is applied to an array type, the element type
13997 is so qualified, not the array type (section 6.7.3 of C99). */
13998 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14000 struct type
*el_type
, *inner_array
;
14002 base_type
= copy_type (base_type
);
14003 inner_array
= base_type
;
14005 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
14007 TYPE_TARGET_TYPE (inner_array
) =
14008 copy_type (TYPE_TARGET_TYPE (inner_array
));
14009 inner_array
= TYPE_TARGET_TYPE (inner_array
);
14012 el_type
= TYPE_TARGET_TYPE (inner_array
);
14013 TYPE_TARGET_TYPE (inner_array
) =
14014 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
14016 return set_die_type (die
, base_type
, cu
);
14019 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
14020 return set_die_type (die
, cv_type
, cu
);
14023 static struct type
*
14024 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14026 struct type
*base_type
, *cv_type
;
14028 base_type
= die_type (die
, cu
);
14030 /* The die_type call above may have already set the type for this DIE. */
14031 cv_type
= get_die_type (die
, cu
);
14035 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
14036 return set_die_type (die
, cv_type
, cu
);
14039 /* Handle DW_TAG_restrict_type. */
14041 static struct type
*
14042 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14044 struct type
*base_type
, *cv_type
;
14046 base_type
= die_type (die
, cu
);
14048 /* The die_type call above may have already set the type for this DIE. */
14049 cv_type
= get_die_type (die
, cu
);
14053 cv_type
= make_restrict_type (base_type
);
14054 return set_die_type (die
, cv_type
, cu
);
14057 /* Extract all information from a DW_TAG_string_type DIE and add to
14058 the user defined type vector. It isn't really a user defined type,
14059 but it behaves like one, with other DIE's using an AT_user_def_type
14060 attribute to reference it. */
14062 static struct type
*
14063 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14065 struct objfile
*objfile
= cu
->objfile
;
14066 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14067 struct type
*type
, *range_type
, *index_type
, *char_type
;
14068 struct attribute
*attr
;
14069 unsigned int length
;
14071 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
14074 length
= DW_UNSND (attr
);
14078 /* Check for the DW_AT_byte_size attribute. */
14079 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14082 length
= DW_UNSND (attr
);
14090 index_type
= objfile_type (objfile
)->builtin_int
;
14091 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
14092 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
14093 type
= create_string_type (NULL
, char_type
, range_type
);
14095 return set_die_type (die
, type
, cu
);
14098 /* Assuming that DIE corresponds to a function, returns nonzero
14099 if the function is prototyped. */
14102 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
14104 struct attribute
*attr
;
14106 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
14107 if (attr
&& (DW_UNSND (attr
) != 0))
14110 /* The DWARF standard implies that the DW_AT_prototyped attribute
14111 is only meaninful for C, but the concept also extends to other
14112 languages that allow unprototyped functions (Eg: Objective C).
14113 For all other languages, assume that functions are always
14115 if (cu
->language
!= language_c
14116 && cu
->language
!= language_objc
14117 && cu
->language
!= language_opencl
)
14120 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14121 prototyped and unprototyped functions; default to prototyped,
14122 since that is more common in modern code (and RealView warns
14123 about unprototyped functions). */
14124 if (producer_is_realview (cu
->producer
))
14130 /* Handle DIES due to C code like:
14134 int (*funcp)(int a, long l);
14138 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14140 static struct type
*
14141 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14143 struct objfile
*objfile
= cu
->objfile
;
14144 struct type
*type
; /* Type that this function returns. */
14145 struct type
*ftype
; /* Function that returns above type. */
14146 struct attribute
*attr
;
14148 type
= die_type (die
, cu
);
14150 /* The die_type call above may have already set the type for this DIE. */
14151 ftype
= get_die_type (die
, cu
);
14155 ftype
= lookup_function_type (type
);
14157 if (prototyped_function_p (die
, cu
))
14158 TYPE_PROTOTYPED (ftype
) = 1;
14160 /* Store the calling convention in the type if it's available in
14161 the subroutine die. Otherwise set the calling convention to
14162 the default value DW_CC_normal. */
14163 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
14165 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
14166 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
14167 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
14169 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
14171 /* We need to add the subroutine type to the die immediately so
14172 we don't infinitely recurse when dealing with parameters
14173 declared as the same subroutine type. */
14174 set_die_type (die
, ftype
, cu
);
14176 if (die
->child
!= NULL
)
14178 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
14179 struct die_info
*child_die
;
14180 int nparams
, iparams
;
14182 /* Count the number of parameters.
14183 FIXME: GDB currently ignores vararg functions, but knows about
14184 vararg member functions. */
14186 child_die
= die
->child
;
14187 while (child_die
&& child_die
->tag
)
14189 if (child_die
->tag
== DW_TAG_formal_parameter
)
14191 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
14192 TYPE_VARARGS (ftype
) = 1;
14193 child_die
= sibling_die (child_die
);
14196 /* Allocate storage for parameters and fill them in. */
14197 TYPE_NFIELDS (ftype
) = nparams
;
14198 TYPE_FIELDS (ftype
) = (struct field
*)
14199 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
14201 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14202 even if we error out during the parameters reading below. */
14203 for (iparams
= 0; iparams
< nparams
; iparams
++)
14204 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
14207 child_die
= die
->child
;
14208 while (child_die
&& child_die
->tag
)
14210 if (child_die
->tag
== DW_TAG_formal_parameter
)
14212 struct type
*arg_type
;
14214 /* DWARF version 2 has no clean way to discern C++
14215 static and non-static member functions. G++ helps
14216 GDB by marking the first parameter for non-static
14217 member functions (which is the this pointer) as
14218 artificial. We pass this information to
14219 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14221 DWARF version 3 added DW_AT_object_pointer, which GCC
14222 4.5 does not yet generate. */
14223 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
14225 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
14228 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
14230 /* GCC/43521: In java, the formal parameter
14231 "this" is sometimes not marked with DW_AT_artificial. */
14232 if (cu
->language
== language_java
)
14234 const char *name
= dwarf2_name (child_die
, cu
);
14236 if (name
&& !strcmp (name
, "this"))
14237 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
14240 arg_type
= die_type (child_die
, cu
);
14242 /* RealView does not mark THIS as const, which the testsuite
14243 expects. GCC marks THIS as const in method definitions,
14244 but not in the class specifications (GCC PR 43053). */
14245 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
14246 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
14249 struct dwarf2_cu
*arg_cu
= cu
;
14250 const char *name
= dwarf2_name (child_die
, cu
);
14252 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
14255 /* If the compiler emits this, use it. */
14256 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
14259 else if (name
&& strcmp (name
, "this") == 0)
14260 /* Function definitions will have the argument names. */
14262 else if (name
== NULL
&& iparams
== 0)
14263 /* Declarations may not have the names, so like
14264 elsewhere in GDB, assume an artificial first
14265 argument is "this". */
14269 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
14273 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
14276 child_die
= sibling_die (child_die
);
14283 static struct type
*
14284 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
14286 struct objfile
*objfile
= cu
->objfile
;
14287 const char *name
= NULL
;
14288 struct type
*this_type
, *target_type
;
14290 name
= dwarf2_full_name (NULL
, die
, cu
);
14291 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
14292 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
14293 TYPE_NAME (this_type
) = name
;
14294 set_die_type (die
, this_type
, cu
);
14295 target_type
= die_type (die
, cu
);
14296 if (target_type
!= this_type
)
14297 TYPE_TARGET_TYPE (this_type
) = target_type
;
14300 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14301 spec and cause infinite loops in GDB. */
14302 complaint (&symfile_complaints
,
14303 _("Self-referential DW_TAG_typedef "
14304 "- DIE at 0x%x [in module %s]"),
14305 die
->offset
.sect_off
, objfile_name (objfile
));
14306 TYPE_TARGET_TYPE (this_type
) = NULL
;
14311 /* Find a representation of a given base type and install
14312 it in the TYPE field of the die. */
14314 static struct type
*
14315 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14317 struct objfile
*objfile
= cu
->objfile
;
14319 struct attribute
*attr
;
14320 int encoding
= 0, size
= 0;
14322 enum type_code code
= TYPE_CODE_INT
;
14323 int type_flags
= 0;
14324 struct type
*target_type
= NULL
;
14326 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
14329 encoding
= DW_UNSND (attr
);
14331 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14334 size
= DW_UNSND (attr
);
14336 name
= dwarf2_name (die
, cu
);
14339 complaint (&symfile_complaints
,
14340 _("DW_AT_name missing from DW_TAG_base_type"));
14345 case DW_ATE_address
:
14346 /* Turn DW_ATE_address into a void * pointer. */
14347 code
= TYPE_CODE_PTR
;
14348 type_flags
|= TYPE_FLAG_UNSIGNED
;
14349 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
14351 case DW_ATE_boolean
:
14352 code
= TYPE_CODE_BOOL
;
14353 type_flags
|= TYPE_FLAG_UNSIGNED
;
14355 case DW_ATE_complex_float
:
14356 code
= TYPE_CODE_COMPLEX
;
14357 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
14359 case DW_ATE_decimal_float
:
14360 code
= TYPE_CODE_DECFLOAT
;
14363 code
= TYPE_CODE_FLT
;
14365 case DW_ATE_signed
:
14367 case DW_ATE_unsigned
:
14368 type_flags
|= TYPE_FLAG_UNSIGNED
;
14369 if (cu
->language
== language_fortran
14371 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
14372 code
= TYPE_CODE_CHAR
;
14374 case DW_ATE_signed_char
:
14375 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14376 || cu
->language
== language_pascal
14377 || cu
->language
== language_fortran
)
14378 code
= TYPE_CODE_CHAR
;
14380 case DW_ATE_unsigned_char
:
14381 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14382 || cu
->language
== language_pascal
14383 || cu
->language
== language_fortran
)
14384 code
= TYPE_CODE_CHAR
;
14385 type_flags
|= TYPE_FLAG_UNSIGNED
;
14388 /* We just treat this as an integer and then recognize the
14389 type by name elsewhere. */
14393 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
14394 dwarf_type_encoding_name (encoding
));
14398 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
14399 TYPE_NAME (type
) = name
;
14400 TYPE_TARGET_TYPE (type
) = target_type
;
14402 if (name
&& strcmp (name
, "char") == 0)
14403 TYPE_NOSIGN (type
) = 1;
14405 return set_die_type (die
, type
, cu
);
14408 /* Parse dwarf attribute if it's a block, reference or constant and put the
14409 resulting value of the attribute into struct bound_prop.
14410 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14413 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
14414 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
14416 struct dwarf2_property_baton
*baton
;
14417 struct obstack
*obstack
= &cu
->objfile
->objfile_obstack
;
14419 if (attr
== NULL
|| prop
== NULL
)
14422 if (attr_form_is_block (attr
))
14424 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14425 baton
->referenced_type
= NULL
;
14426 baton
->locexpr
.per_cu
= cu
->per_cu
;
14427 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
14428 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
14429 prop
->data
.baton
= baton
;
14430 prop
->kind
= PROP_LOCEXPR
;
14431 gdb_assert (prop
->data
.baton
!= NULL
);
14433 else if (attr_form_is_ref (attr
))
14435 struct dwarf2_cu
*target_cu
= cu
;
14436 struct die_info
*target_die
;
14437 struct attribute
*target_attr
;
14439 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14440 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
14441 if (target_attr
== NULL
)
14444 if (attr_form_is_section_offset (target_attr
))
14446 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14447 baton
->referenced_type
= die_type (target_die
, target_cu
);
14448 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
14449 prop
->data
.baton
= baton
;
14450 prop
->kind
= PROP_LOCLIST
;
14451 gdb_assert (prop
->data
.baton
!= NULL
);
14453 else if (attr_form_is_block (target_attr
))
14455 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14456 baton
->referenced_type
= die_type (target_die
, target_cu
);
14457 baton
->locexpr
.per_cu
= cu
->per_cu
;
14458 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
14459 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
14460 prop
->data
.baton
= baton
;
14461 prop
->kind
= PROP_LOCEXPR
;
14462 gdb_assert (prop
->data
.baton
!= NULL
);
14466 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14467 "dynamic property");
14471 else if (attr_form_is_constant (attr
))
14473 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
14474 prop
->kind
= PROP_CONST
;
14478 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
14479 dwarf2_name (die
, cu
));
14486 /* Read the given DW_AT_subrange DIE. */
14488 static struct type
*
14489 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14491 struct type
*base_type
, *orig_base_type
;
14492 struct type
*range_type
;
14493 struct attribute
*attr
;
14494 struct dynamic_prop low
, high
;
14495 int low_default_is_valid
;
14497 LONGEST negative_mask
;
14499 orig_base_type
= die_type (die
, cu
);
14500 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14501 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14502 creating the range type, but we use the result of check_typedef
14503 when examining properties of the type. */
14504 base_type
= check_typedef (orig_base_type
);
14506 /* The die_type call above may have already set the type for this DIE. */
14507 range_type
= get_die_type (die
, cu
);
14511 low
.kind
= PROP_CONST
;
14512 high
.kind
= PROP_CONST
;
14513 high
.data
.const_val
= 0;
14515 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14516 omitting DW_AT_lower_bound. */
14517 switch (cu
->language
)
14520 case language_cplus
:
14521 low
.data
.const_val
= 0;
14522 low_default_is_valid
= 1;
14524 case language_fortran
:
14525 low
.data
.const_val
= 1;
14526 low_default_is_valid
= 1;
14529 case language_java
:
14530 case language_objc
:
14531 low
.data
.const_val
= 0;
14532 low_default_is_valid
= (cu
->header
.version
>= 4);
14536 case language_pascal
:
14537 low
.data
.const_val
= 1;
14538 low_default_is_valid
= (cu
->header
.version
>= 4);
14541 low
.data
.const_val
= 0;
14542 low_default_is_valid
= 0;
14546 /* FIXME: For variable sized arrays either of these could be
14547 a variable rather than a constant value. We'll allow it,
14548 but we don't know how to handle it. */
14549 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
14552 = dwarf2_get_attr_constant_value (attr
, low
.data
.const_val
);
14553 else if (!low_default_is_valid
)
14554 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
14555 "- DIE at 0x%x [in module %s]"),
14556 die
->offset
.sect_off
, objfile_name (cu
->objfile
));
14558 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
14559 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14561 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
14564 int count
= dwarf2_get_attr_constant_value (attr
, 1);
14565 high
.data
.const_val
= low
.data
.const_val
+ count
- 1;
14569 /* Unspecified array length. */
14570 high
.data
.const_val
= low
.data
.const_val
- 1;
14574 /* Dwarf-2 specifications explicitly allows to create subrange types
14575 without specifying a base type.
14576 In that case, the base type must be set to the type of
14577 the lower bound, upper bound or count, in that order, if any of these
14578 three attributes references an object that has a type.
14579 If no base type is found, the Dwarf-2 specifications say that
14580 a signed integer type of size equal to the size of an address should
14582 For the following C code: `extern char gdb_int [];'
14583 GCC produces an empty range DIE.
14584 FIXME: muller/2010-05-28: Possible references to object for low bound,
14585 high bound or count are not yet handled by this code. */
14586 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
14588 struct objfile
*objfile
= cu
->objfile
;
14589 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14590 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
14591 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
14593 /* Test "int", "long int", and "long long int" objfile types,
14594 and select the first one having a size above or equal to the
14595 architecture address size. */
14596 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14597 base_type
= int_type
;
14600 int_type
= objfile_type (objfile
)->builtin_long
;
14601 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14602 base_type
= int_type
;
14605 int_type
= objfile_type (objfile
)->builtin_long_long
;
14606 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14607 base_type
= int_type
;
14612 /* Normally, the DWARF producers are expected to use a signed
14613 constant form (Eg. DW_FORM_sdata) to express negative bounds.
14614 But this is unfortunately not always the case, as witnessed
14615 with GCC, for instance, where the ambiguous DW_FORM_dataN form
14616 is used instead. To work around that ambiguity, we treat
14617 the bounds as signed, and thus sign-extend their values, when
14618 the base type is signed. */
14620 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
14621 if (low
.kind
== PROP_CONST
14622 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
14623 low
.data
.const_val
|= negative_mask
;
14624 if (high
.kind
== PROP_CONST
14625 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
14626 high
.data
.const_val
|= negative_mask
;
14628 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
14630 /* Ada expects an empty array on no boundary attributes. */
14631 if (attr
== NULL
&& cu
->language
!= language_ada
)
14632 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
14634 name
= dwarf2_name (die
, cu
);
14636 TYPE_NAME (range_type
) = name
;
14638 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14640 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
14642 set_die_type (die
, range_type
, cu
);
14644 /* set_die_type should be already done. */
14645 set_descriptive_type (range_type
, die
, cu
);
14650 static struct type
*
14651 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14655 /* For now, we only support the C meaning of an unspecified type: void. */
14657 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
14658 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
14660 return set_die_type (die
, type
, cu
);
14663 /* Read a single die and all its descendents. Set the die's sibling
14664 field to NULL; set other fields in the die correctly, and set all
14665 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
14666 location of the info_ptr after reading all of those dies. PARENT
14667 is the parent of the die in question. */
14669 static struct die_info
*
14670 read_die_and_children (const struct die_reader_specs
*reader
,
14671 const gdb_byte
*info_ptr
,
14672 const gdb_byte
**new_info_ptr
,
14673 struct die_info
*parent
)
14675 struct die_info
*die
;
14676 const gdb_byte
*cur_ptr
;
14679 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
14682 *new_info_ptr
= cur_ptr
;
14685 store_in_ref_table (die
, reader
->cu
);
14688 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
14692 *new_info_ptr
= cur_ptr
;
14695 die
->sibling
= NULL
;
14696 die
->parent
= parent
;
14700 /* Read a die, all of its descendents, and all of its siblings; set
14701 all of the fields of all of the dies correctly. Arguments are as
14702 in read_die_and_children. */
14704 static struct die_info
*
14705 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
14706 const gdb_byte
*info_ptr
,
14707 const gdb_byte
**new_info_ptr
,
14708 struct die_info
*parent
)
14710 struct die_info
*first_die
, *last_sibling
;
14711 const gdb_byte
*cur_ptr
;
14713 cur_ptr
= info_ptr
;
14714 first_die
= last_sibling
= NULL
;
14718 struct die_info
*die
14719 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
14723 *new_info_ptr
= cur_ptr
;
14730 last_sibling
->sibling
= die
;
14732 last_sibling
= die
;
14736 /* Read a die, all of its descendents, and all of its siblings; set
14737 all of the fields of all of the dies correctly. Arguments are as
14738 in read_die_and_children.
14739 This the main entry point for reading a DIE and all its children. */
14741 static struct die_info
*
14742 read_die_and_siblings (const struct die_reader_specs
*reader
,
14743 const gdb_byte
*info_ptr
,
14744 const gdb_byte
**new_info_ptr
,
14745 struct die_info
*parent
)
14747 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
14748 new_info_ptr
, parent
);
14750 if (dwarf2_die_debug
)
14752 fprintf_unfiltered (gdb_stdlog
,
14753 "Read die from %s@0x%x of %s:\n",
14754 get_section_name (reader
->die_section
),
14755 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
14756 bfd_get_filename (reader
->abfd
));
14757 dump_die (die
, dwarf2_die_debug
);
14763 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
14765 The caller is responsible for filling in the extra attributes
14766 and updating (*DIEP)->num_attrs.
14767 Set DIEP to point to a newly allocated die with its information,
14768 except for its child, sibling, and parent fields.
14769 Set HAS_CHILDREN to tell whether the die has children or not. */
14771 static const gdb_byte
*
14772 read_full_die_1 (const struct die_reader_specs
*reader
,
14773 struct die_info
**diep
, const gdb_byte
*info_ptr
,
14774 int *has_children
, int num_extra_attrs
)
14776 unsigned int abbrev_number
, bytes_read
, i
;
14777 sect_offset offset
;
14778 struct abbrev_info
*abbrev
;
14779 struct die_info
*die
;
14780 struct dwarf2_cu
*cu
= reader
->cu
;
14781 bfd
*abfd
= reader
->abfd
;
14783 offset
.sect_off
= info_ptr
- reader
->buffer
;
14784 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
14785 info_ptr
+= bytes_read
;
14786 if (!abbrev_number
)
14793 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
14795 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
14797 bfd_get_filename (abfd
));
14799 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
14800 die
->offset
= offset
;
14801 die
->tag
= abbrev
->tag
;
14802 die
->abbrev
= abbrev_number
;
14804 /* Make the result usable.
14805 The caller needs to update num_attrs after adding the extra
14807 die
->num_attrs
= abbrev
->num_attrs
;
14809 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
14810 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
14814 *has_children
= abbrev
->has_children
;
14818 /* Read a die and all its attributes.
14819 Set DIEP to point to a newly allocated die with its information,
14820 except for its child, sibling, and parent fields.
14821 Set HAS_CHILDREN to tell whether the die has children or not. */
14823 static const gdb_byte
*
14824 read_full_die (const struct die_reader_specs
*reader
,
14825 struct die_info
**diep
, const gdb_byte
*info_ptr
,
14828 const gdb_byte
*result
;
14830 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
14832 if (dwarf2_die_debug
)
14834 fprintf_unfiltered (gdb_stdlog
,
14835 "Read die from %s@0x%x of %s:\n",
14836 get_section_name (reader
->die_section
),
14837 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
14838 bfd_get_filename (reader
->abfd
));
14839 dump_die (*diep
, dwarf2_die_debug
);
14845 /* Abbreviation tables.
14847 In DWARF version 2, the description of the debugging information is
14848 stored in a separate .debug_abbrev section. Before we read any
14849 dies from a section we read in all abbreviations and install them
14850 in a hash table. */
14852 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
14854 static struct abbrev_info
*
14855 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
14857 struct abbrev_info
*abbrev
;
14859 abbrev
= (struct abbrev_info
*)
14860 obstack_alloc (&abbrev_table
->abbrev_obstack
, sizeof (struct abbrev_info
));
14861 memset (abbrev
, 0, sizeof (struct abbrev_info
));
14865 /* Add an abbreviation to the table. */
14868 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
14869 unsigned int abbrev_number
,
14870 struct abbrev_info
*abbrev
)
14872 unsigned int hash_number
;
14874 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
14875 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
14876 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
14879 /* Look up an abbrev in the table.
14880 Returns NULL if the abbrev is not found. */
14882 static struct abbrev_info
*
14883 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
14884 unsigned int abbrev_number
)
14886 unsigned int hash_number
;
14887 struct abbrev_info
*abbrev
;
14889 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
14890 abbrev
= abbrev_table
->abbrevs
[hash_number
];
14894 if (abbrev
->number
== abbrev_number
)
14896 abbrev
= abbrev
->next
;
14901 /* Read in an abbrev table. */
14903 static struct abbrev_table
*
14904 abbrev_table_read_table (struct dwarf2_section_info
*section
,
14905 sect_offset offset
)
14907 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14908 bfd
*abfd
= get_section_bfd_owner (section
);
14909 struct abbrev_table
*abbrev_table
;
14910 const gdb_byte
*abbrev_ptr
;
14911 struct abbrev_info
*cur_abbrev
;
14912 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
14913 unsigned int abbrev_form
;
14914 struct attr_abbrev
*cur_attrs
;
14915 unsigned int allocated_attrs
;
14917 abbrev_table
= XNEW (struct abbrev_table
);
14918 abbrev_table
->offset
= offset
;
14919 obstack_init (&abbrev_table
->abbrev_obstack
);
14920 abbrev_table
->abbrevs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
14922 * sizeof (struct abbrev_info
*)));
14923 memset (abbrev_table
->abbrevs
, 0,
14924 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
14926 dwarf2_read_section (objfile
, section
);
14927 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
14928 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
14929 abbrev_ptr
+= bytes_read
;
14931 allocated_attrs
= ATTR_ALLOC_CHUNK
;
14932 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
14934 /* Loop until we reach an abbrev number of 0. */
14935 while (abbrev_number
)
14937 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
14939 /* read in abbrev header */
14940 cur_abbrev
->number
= abbrev_number
;
14941 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
14942 abbrev_ptr
+= bytes_read
;
14943 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
14946 /* now read in declarations */
14947 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
14948 abbrev_ptr
+= bytes_read
;
14949 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
14950 abbrev_ptr
+= bytes_read
;
14951 while (abbrev_name
)
14953 if (cur_abbrev
->num_attrs
== allocated_attrs
)
14955 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
14957 = xrealloc (cur_attrs
, (allocated_attrs
14958 * sizeof (struct attr_abbrev
)));
14961 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
14962 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
14963 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
14964 abbrev_ptr
+= bytes_read
;
14965 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
14966 abbrev_ptr
+= bytes_read
;
14969 cur_abbrev
->attrs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
14970 (cur_abbrev
->num_attrs
14971 * sizeof (struct attr_abbrev
)));
14972 memcpy (cur_abbrev
->attrs
, cur_attrs
,
14973 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
14975 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
14977 /* Get next abbreviation.
14978 Under Irix6 the abbreviations for a compilation unit are not
14979 always properly terminated with an abbrev number of 0.
14980 Exit loop if we encounter an abbreviation which we have
14981 already read (which means we are about to read the abbreviations
14982 for the next compile unit) or if the end of the abbreviation
14983 table is reached. */
14984 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
14986 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
14987 abbrev_ptr
+= bytes_read
;
14988 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
14993 return abbrev_table
;
14996 /* Free the resources held by ABBREV_TABLE. */
14999 abbrev_table_free (struct abbrev_table
*abbrev_table
)
15001 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
15002 xfree (abbrev_table
);
15005 /* Same as abbrev_table_free but as a cleanup.
15006 We pass in a pointer to the pointer to the table so that we can
15007 set the pointer to NULL when we're done. It also simplifies
15008 build_type_unit_groups. */
15011 abbrev_table_free_cleanup (void *table_ptr
)
15013 struct abbrev_table
**abbrev_table_ptr
= table_ptr
;
15015 if (*abbrev_table_ptr
!= NULL
)
15016 abbrev_table_free (*abbrev_table_ptr
);
15017 *abbrev_table_ptr
= NULL
;
15020 /* Read the abbrev table for CU from ABBREV_SECTION. */
15023 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
15024 struct dwarf2_section_info
*abbrev_section
)
15027 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
15030 /* Release the memory used by the abbrev table for a compilation unit. */
15033 dwarf2_free_abbrev_table (void *ptr_to_cu
)
15035 struct dwarf2_cu
*cu
= ptr_to_cu
;
15037 if (cu
->abbrev_table
!= NULL
)
15038 abbrev_table_free (cu
->abbrev_table
);
15039 /* Set this to NULL so that we SEGV if we try to read it later,
15040 and also because free_comp_unit verifies this is NULL. */
15041 cu
->abbrev_table
= NULL
;
15044 /* Returns nonzero if TAG represents a type that we might generate a partial
15048 is_type_tag_for_partial (int tag
)
15053 /* Some types that would be reasonable to generate partial symbols for,
15054 that we don't at present. */
15055 case DW_TAG_array_type
:
15056 case DW_TAG_file_type
:
15057 case DW_TAG_ptr_to_member_type
:
15058 case DW_TAG_set_type
:
15059 case DW_TAG_string_type
:
15060 case DW_TAG_subroutine_type
:
15062 case DW_TAG_base_type
:
15063 case DW_TAG_class_type
:
15064 case DW_TAG_interface_type
:
15065 case DW_TAG_enumeration_type
:
15066 case DW_TAG_structure_type
:
15067 case DW_TAG_subrange_type
:
15068 case DW_TAG_typedef
:
15069 case DW_TAG_union_type
:
15076 /* Load all DIEs that are interesting for partial symbols into memory. */
15078 static struct partial_die_info
*
15079 load_partial_dies (const struct die_reader_specs
*reader
,
15080 const gdb_byte
*info_ptr
, int building_psymtab
)
15082 struct dwarf2_cu
*cu
= reader
->cu
;
15083 struct objfile
*objfile
= cu
->objfile
;
15084 struct partial_die_info
*part_die
;
15085 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
15086 struct abbrev_info
*abbrev
;
15087 unsigned int bytes_read
;
15088 unsigned int load_all
= 0;
15089 int nesting_level
= 1;
15094 gdb_assert (cu
->per_cu
!= NULL
);
15095 if (cu
->per_cu
->load_all_dies
)
15099 = htab_create_alloc_ex (cu
->header
.length
/ 12,
15103 &cu
->comp_unit_obstack
,
15104 hashtab_obstack_allocate
,
15105 dummy_obstack_deallocate
);
15107 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15108 sizeof (struct partial_die_info
));
15112 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
15114 /* A NULL abbrev means the end of a series of children. */
15115 if (abbrev
== NULL
)
15117 if (--nesting_level
== 0)
15119 /* PART_DIE was probably the last thing allocated on the
15120 comp_unit_obstack, so we could call obstack_free
15121 here. We don't do that because the waste is small,
15122 and will be cleaned up when we're done with this
15123 compilation unit. This way, we're also more robust
15124 against other users of the comp_unit_obstack. */
15127 info_ptr
+= bytes_read
;
15128 last_die
= parent_die
;
15129 parent_die
= parent_die
->die_parent
;
15133 /* Check for template arguments. We never save these; if
15134 they're seen, we just mark the parent, and go on our way. */
15135 if (parent_die
!= NULL
15136 && cu
->language
== language_cplus
15137 && (abbrev
->tag
== DW_TAG_template_type_param
15138 || abbrev
->tag
== DW_TAG_template_value_param
))
15140 parent_die
->has_template_arguments
= 1;
15144 /* We don't need a partial DIE for the template argument. */
15145 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15150 /* We only recurse into c++ subprograms looking for template arguments.
15151 Skip their other children. */
15153 && cu
->language
== language_cplus
15154 && parent_die
!= NULL
15155 && parent_die
->tag
== DW_TAG_subprogram
)
15157 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15161 /* Check whether this DIE is interesting enough to save. Normally
15162 we would not be interested in members here, but there may be
15163 later variables referencing them via DW_AT_specification (for
15164 static members). */
15166 && !is_type_tag_for_partial (abbrev
->tag
)
15167 && abbrev
->tag
!= DW_TAG_constant
15168 && abbrev
->tag
!= DW_TAG_enumerator
15169 && abbrev
->tag
!= DW_TAG_subprogram
15170 && abbrev
->tag
!= DW_TAG_lexical_block
15171 && abbrev
->tag
!= DW_TAG_variable
15172 && abbrev
->tag
!= DW_TAG_namespace
15173 && abbrev
->tag
!= DW_TAG_module
15174 && abbrev
->tag
!= DW_TAG_member
15175 && abbrev
->tag
!= DW_TAG_imported_unit
15176 && abbrev
->tag
!= DW_TAG_imported_declaration
)
15178 /* Otherwise we skip to the next sibling, if any. */
15179 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15183 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
15186 /* This two-pass algorithm for processing partial symbols has a
15187 high cost in cache pressure. Thus, handle some simple cases
15188 here which cover the majority of C partial symbols. DIEs
15189 which neither have specification tags in them, nor could have
15190 specification tags elsewhere pointing at them, can simply be
15191 processed and discarded.
15193 This segment is also optional; scan_partial_symbols and
15194 add_partial_symbol will handle these DIEs if we chain
15195 them in normally. When compilers which do not emit large
15196 quantities of duplicate debug information are more common,
15197 this code can probably be removed. */
15199 /* Any complete simple types at the top level (pretty much all
15200 of them, for a language without namespaces), can be processed
15202 if (parent_die
== NULL
15203 && part_die
->has_specification
== 0
15204 && part_die
->is_declaration
== 0
15205 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
15206 || part_die
->tag
== DW_TAG_base_type
15207 || part_die
->tag
== DW_TAG_subrange_type
))
15209 if (building_psymtab
&& part_die
->name
!= NULL
)
15210 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15211 VAR_DOMAIN
, LOC_TYPEDEF
,
15212 &objfile
->static_psymbols
,
15213 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15214 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15218 /* The exception for DW_TAG_typedef with has_children above is
15219 a workaround of GCC PR debug/47510. In the case of this complaint
15220 type_name_no_tag_or_error will error on such types later.
15222 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15223 it could not find the child DIEs referenced later, this is checked
15224 above. In correct DWARF DW_TAG_typedef should have no children. */
15226 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
15227 complaint (&symfile_complaints
,
15228 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15229 "- DIE at 0x%x [in module %s]"),
15230 part_die
->offset
.sect_off
, objfile_name (objfile
));
15232 /* If we're at the second level, and we're an enumerator, and
15233 our parent has no specification (meaning possibly lives in a
15234 namespace elsewhere), then we can add the partial symbol now
15235 instead of queueing it. */
15236 if (part_die
->tag
== DW_TAG_enumerator
15237 && parent_die
!= NULL
15238 && parent_die
->die_parent
== NULL
15239 && parent_die
->tag
== DW_TAG_enumeration_type
15240 && parent_die
->has_specification
== 0)
15242 if (part_die
->name
== NULL
)
15243 complaint (&symfile_complaints
,
15244 _("malformed enumerator DIE ignored"));
15245 else if (building_psymtab
)
15246 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15247 VAR_DOMAIN
, LOC_CONST
,
15248 (cu
->language
== language_cplus
15249 || cu
->language
== language_java
)
15250 ? &objfile
->global_psymbols
15251 : &objfile
->static_psymbols
,
15252 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15254 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15258 /* We'll save this DIE so link it in. */
15259 part_die
->die_parent
= parent_die
;
15260 part_die
->die_sibling
= NULL
;
15261 part_die
->die_child
= NULL
;
15263 if (last_die
&& last_die
== parent_die
)
15264 last_die
->die_child
= part_die
;
15266 last_die
->die_sibling
= part_die
;
15268 last_die
= part_die
;
15270 if (first_die
== NULL
)
15271 first_die
= part_die
;
15273 /* Maybe add the DIE to the hash table. Not all DIEs that we
15274 find interesting need to be in the hash table, because we
15275 also have the parent/sibling/child chains; only those that we
15276 might refer to by offset later during partial symbol reading.
15278 For now this means things that might have be the target of a
15279 DW_AT_specification, DW_AT_abstract_origin, or
15280 DW_AT_extension. DW_AT_extension will refer only to
15281 namespaces; DW_AT_abstract_origin refers to functions (and
15282 many things under the function DIE, but we do not recurse
15283 into function DIEs during partial symbol reading) and
15284 possibly variables as well; DW_AT_specification refers to
15285 declarations. Declarations ought to have the DW_AT_declaration
15286 flag. It happens that GCC forgets to put it in sometimes, but
15287 only for functions, not for types.
15289 Adding more things than necessary to the hash table is harmless
15290 except for the performance cost. Adding too few will result in
15291 wasted time in find_partial_die, when we reread the compilation
15292 unit with load_all_dies set. */
15295 || abbrev
->tag
== DW_TAG_constant
15296 || abbrev
->tag
== DW_TAG_subprogram
15297 || abbrev
->tag
== DW_TAG_variable
15298 || abbrev
->tag
== DW_TAG_namespace
15299 || part_die
->is_declaration
)
15303 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
15304 part_die
->offset
.sect_off
, INSERT
);
15308 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15309 sizeof (struct partial_die_info
));
15311 /* For some DIEs we want to follow their children (if any). For C
15312 we have no reason to follow the children of structures; for other
15313 languages we have to, so that we can get at method physnames
15314 to infer fully qualified class names, for DW_AT_specification,
15315 and for C++ template arguments. For C++, we also look one level
15316 inside functions to find template arguments (if the name of the
15317 function does not already contain the template arguments).
15319 For Ada, we need to scan the children of subprograms and lexical
15320 blocks as well because Ada allows the definition of nested
15321 entities that could be interesting for the debugger, such as
15322 nested subprograms for instance. */
15323 if (last_die
->has_children
15325 || last_die
->tag
== DW_TAG_namespace
15326 || last_die
->tag
== DW_TAG_module
15327 || last_die
->tag
== DW_TAG_enumeration_type
15328 || (cu
->language
== language_cplus
15329 && last_die
->tag
== DW_TAG_subprogram
15330 && (last_die
->name
== NULL
15331 || strchr (last_die
->name
, '<') == NULL
))
15332 || (cu
->language
!= language_c
15333 && (last_die
->tag
== DW_TAG_class_type
15334 || last_die
->tag
== DW_TAG_interface_type
15335 || last_die
->tag
== DW_TAG_structure_type
15336 || last_die
->tag
== DW_TAG_union_type
))
15337 || (cu
->language
== language_ada
15338 && (last_die
->tag
== DW_TAG_subprogram
15339 || last_die
->tag
== DW_TAG_lexical_block
))))
15342 parent_die
= last_die
;
15346 /* Otherwise we skip to the next sibling, if any. */
15347 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
15349 /* Back to the top, do it again. */
15353 /* Read a minimal amount of information into the minimal die structure. */
15355 static const gdb_byte
*
15356 read_partial_die (const struct die_reader_specs
*reader
,
15357 struct partial_die_info
*part_die
,
15358 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
15359 const gdb_byte
*info_ptr
)
15361 struct dwarf2_cu
*cu
= reader
->cu
;
15362 struct objfile
*objfile
= cu
->objfile
;
15363 const gdb_byte
*buffer
= reader
->buffer
;
15365 struct attribute attr
;
15366 int has_low_pc_attr
= 0;
15367 int has_high_pc_attr
= 0;
15368 int high_pc_relative
= 0;
15370 memset (part_die
, 0, sizeof (struct partial_die_info
));
15372 part_die
->offset
.sect_off
= info_ptr
- buffer
;
15374 info_ptr
+= abbrev_len
;
15376 if (abbrev
== NULL
)
15379 part_die
->tag
= abbrev
->tag
;
15380 part_die
->has_children
= abbrev
->has_children
;
15382 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15384 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
15386 /* Store the data if it is of an attribute we want to keep in a
15387 partial symbol table. */
15391 switch (part_die
->tag
)
15393 case DW_TAG_compile_unit
:
15394 case DW_TAG_partial_unit
:
15395 case DW_TAG_type_unit
:
15396 /* Compilation units have a DW_AT_name that is a filename, not
15397 a source language identifier. */
15398 case DW_TAG_enumeration_type
:
15399 case DW_TAG_enumerator
:
15400 /* These tags always have simple identifiers already; no need
15401 to canonicalize them. */
15402 part_die
->name
= DW_STRING (&attr
);
15406 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
15407 &objfile
->objfile_obstack
);
15411 case DW_AT_linkage_name
:
15412 case DW_AT_MIPS_linkage_name
:
15413 /* Note that both forms of linkage name might appear. We
15414 assume they will be the same, and we only store the last
15416 if (cu
->language
== language_ada
)
15417 part_die
->name
= DW_STRING (&attr
);
15418 part_die
->linkage_name
= DW_STRING (&attr
);
15421 has_low_pc_attr
= 1;
15422 part_die
->lowpc
= attr_value_as_address (&attr
);
15424 case DW_AT_high_pc
:
15425 has_high_pc_attr
= 1;
15426 part_die
->highpc
= attr_value_as_address (&attr
);
15427 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
15428 high_pc_relative
= 1;
15430 case DW_AT_location
:
15431 /* Support the .debug_loc offsets. */
15432 if (attr_form_is_block (&attr
))
15434 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
15436 else if (attr_form_is_section_offset (&attr
))
15438 dwarf2_complex_location_expr_complaint ();
15442 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15443 "partial symbol information");
15446 case DW_AT_external
:
15447 part_die
->is_external
= DW_UNSND (&attr
);
15449 case DW_AT_declaration
:
15450 part_die
->is_declaration
= DW_UNSND (&attr
);
15453 part_die
->has_type
= 1;
15455 case DW_AT_abstract_origin
:
15456 case DW_AT_specification
:
15457 case DW_AT_extension
:
15458 part_die
->has_specification
= 1;
15459 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
15460 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15461 || cu
->per_cu
->is_dwz
);
15463 case DW_AT_sibling
:
15464 /* Ignore absolute siblings, they might point outside of
15465 the current compile unit. */
15466 if (attr
.form
== DW_FORM_ref_addr
)
15467 complaint (&symfile_complaints
,
15468 _("ignoring absolute DW_AT_sibling"));
15471 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
15472 const gdb_byte
*sibling_ptr
= buffer
+ off
;
15474 if (sibling_ptr
< info_ptr
)
15475 complaint (&symfile_complaints
,
15476 _("DW_AT_sibling points backwards"));
15478 part_die
->sibling
= sibling_ptr
;
15481 case DW_AT_byte_size
:
15482 part_die
->has_byte_size
= 1;
15484 case DW_AT_calling_convention
:
15485 /* DWARF doesn't provide a way to identify a program's source-level
15486 entry point. DW_AT_calling_convention attributes are only meant
15487 to describe functions' calling conventions.
15489 However, because it's a necessary piece of information in
15490 Fortran, and because DW_CC_program is the only piece of debugging
15491 information whose definition refers to a 'main program' at all,
15492 several compilers have begun marking Fortran main programs with
15493 DW_CC_program --- even when those functions use the standard
15494 calling conventions.
15496 So until DWARF specifies a way to provide this information and
15497 compilers pick up the new representation, we'll support this
15499 if (DW_UNSND (&attr
) == DW_CC_program
15500 && cu
->language
== language_fortran
)
15501 set_objfile_main_name (objfile
, part_die
->name
, language_fortran
);
15504 if (DW_UNSND (&attr
) == DW_INL_inlined
15505 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
15506 part_die
->may_be_inlined
= 1;
15510 if (part_die
->tag
== DW_TAG_imported_unit
)
15512 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
15513 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15514 || cu
->per_cu
->is_dwz
);
15523 if (high_pc_relative
)
15524 part_die
->highpc
+= part_die
->lowpc
;
15526 if (has_low_pc_attr
&& has_high_pc_attr
)
15528 /* When using the GNU linker, .gnu.linkonce. sections are used to
15529 eliminate duplicate copies of functions and vtables and such.
15530 The linker will arbitrarily choose one and discard the others.
15531 The AT_*_pc values for such functions refer to local labels in
15532 these sections. If the section from that file was discarded, the
15533 labels are not in the output, so the relocs get a value of 0.
15534 If this is a discarded function, mark the pc bounds as invalid,
15535 so that GDB will ignore it. */
15536 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
15538 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15540 complaint (&symfile_complaints
,
15541 _("DW_AT_low_pc %s is zero "
15542 "for DIE at 0x%x [in module %s]"),
15543 paddress (gdbarch
, part_die
->lowpc
),
15544 part_die
->offset
.sect_off
, objfile_name (objfile
));
15546 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15547 else if (part_die
->lowpc
>= part_die
->highpc
)
15549 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15551 complaint (&symfile_complaints
,
15552 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15553 "for DIE at 0x%x [in module %s]"),
15554 paddress (gdbarch
, part_die
->lowpc
),
15555 paddress (gdbarch
, part_die
->highpc
),
15556 part_die
->offset
.sect_off
, objfile_name (objfile
));
15559 part_die
->has_pc_info
= 1;
15565 /* Find a cached partial DIE at OFFSET in CU. */
15567 static struct partial_die_info
*
15568 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
15570 struct partial_die_info
*lookup_die
= NULL
;
15571 struct partial_die_info part_die
;
15573 part_die
.offset
= offset
;
15574 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
15580 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15581 except in the case of .debug_types DIEs which do not reference
15582 outside their CU (they do however referencing other types via
15583 DW_FORM_ref_sig8). */
15585 static struct partial_die_info
*
15586 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
15588 struct objfile
*objfile
= cu
->objfile
;
15589 struct dwarf2_per_cu_data
*per_cu
= NULL
;
15590 struct partial_die_info
*pd
= NULL
;
15592 if (offset_in_dwz
== cu
->per_cu
->is_dwz
15593 && offset_in_cu_p (&cu
->header
, offset
))
15595 pd
= find_partial_die_in_comp_unit (offset
, cu
);
15598 /* We missed recording what we needed.
15599 Load all dies and try again. */
15600 per_cu
= cu
->per_cu
;
15604 /* TUs don't reference other CUs/TUs (except via type signatures). */
15605 if (cu
->per_cu
->is_debug_types
)
15607 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
15608 " external reference to offset 0x%lx [in module %s].\n"),
15609 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
15610 bfd_get_filename (objfile
->obfd
));
15612 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
15615 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
15616 load_partial_comp_unit (per_cu
);
15618 per_cu
->cu
->last_used
= 0;
15619 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
15622 /* If we didn't find it, and not all dies have been loaded,
15623 load them all and try again. */
15625 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
15627 per_cu
->load_all_dies
= 1;
15629 /* This is nasty. When we reread the DIEs, somewhere up the call chain
15630 THIS_CU->cu may already be in use. So we can't just free it and
15631 replace its DIEs with the ones we read in. Instead, we leave those
15632 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
15633 and clobber THIS_CU->cu->partial_dies with the hash table for the new
15635 load_partial_comp_unit (per_cu
);
15637 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
15641 internal_error (__FILE__
, __LINE__
,
15642 _("could not find partial DIE 0x%x "
15643 "in cache [from module %s]\n"),
15644 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
15648 /* See if we can figure out if the class lives in a namespace. We do
15649 this by looking for a member function; its demangled name will
15650 contain namespace info, if there is any. */
15653 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
15654 struct dwarf2_cu
*cu
)
15656 /* NOTE: carlton/2003-10-07: Getting the info this way changes
15657 what template types look like, because the demangler
15658 frequently doesn't give the same name as the debug info. We
15659 could fix this by only using the demangled name to get the
15660 prefix (but see comment in read_structure_type). */
15662 struct partial_die_info
*real_pdi
;
15663 struct partial_die_info
*child_pdi
;
15665 /* If this DIE (this DIE's specification, if any) has a parent, then
15666 we should not do this. We'll prepend the parent's fully qualified
15667 name when we create the partial symbol. */
15669 real_pdi
= struct_pdi
;
15670 while (real_pdi
->has_specification
)
15671 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
15672 real_pdi
->spec_is_dwz
, cu
);
15674 if (real_pdi
->die_parent
!= NULL
)
15677 for (child_pdi
= struct_pdi
->die_child
;
15679 child_pdi
= child_pdi
->die_sibling
)
15681 if (child_pdi
->tag
== DW_TAG_subprogram
15682 && child_pdi
->linkage_name
!= NULL
)
15684 char *actual_class_name
15685 = language_class_name_from_physname (cu
->language_defn
,
15686 child_pdi
->linkage_name
);
15687 if (actual_class_name
!= NULL
)
15690 = obstack_copy0 (&cu
->objfile
->objfile_obstack
,
15692 strlen (actual_class_name
));
15693 xfree (actual_class_name
);
15700 /* Adjust PART_DIE before generating a symbol for it. This function
15701 may set the is_external flag or change the DIE's name. */
15704 fixup_partial_die (struct partial_die_info
*part_die
,
15705 struct dwarf2_cu
*cu
)
15707 /* Once we've fixed up a die, there's no point in doing so again.
15708 This also avoids a memory leak if we were to call
15709 guess_partial_die_structure_name multiple times. */
15710 if (part_die
->fixup_called
)
15713 /* If we found a reference attribute and the DIE has no name, try
15714 to find a name in the referred to DIE. */
15716 if (part_die
->name
== NULL
&& part_die
->has_specification
)
15718 struct partial_die_info
*spec_die
;
15720 spec_die
= find_partial_die (part_die
->spec_offset
,
15721 part_die
->spec_is_dwz
, cu
);
15723 fixup_partial_die (spec_die
, cu
);
15725 if (spec_die
->name
)
15727 part_die
->name
= spec_die
->name
;
15729 /* Copy DW_AT_external attribute if it is set. */
15730 if (spec_die
->is_external
)
15731 part_die
->is_external
= spec_die
->is_external
;
15735 /* Set default names for some unnamed DIEs. */
15737 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
15738 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
15740 /* If there is no parent die to provide a namespace, and there are
15741 children, see if we can determine the namespace from their linkage
15743 if (cu
->language
== language_cplus
15744 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
15745 && part_die
->die_parent
== NULL
15746 && part_die
->has_children
15747 && (part_die
->tag
== DW_TAG_class_type
15748 || part_die
->tag
== DW_TAG_structure_type
15749 || part_die
->tag
== DW_TAG_union_type
))
15750 guess_partial_die_structure_name (part_die
, cu
);
15752 /* GCC might emit a nameless struct or union that has a linkage
15753 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
15754 if (part_die
->name
== NULL
15755 && (part_die
->tag
== DW_TAG_class_type
15756 || part_die
->tag
== DW_TAG_interface_type
15757 || part_die
->tag
== DW_TAG_structure_type
15758 || part_die
->tag
== DW_TAG_union_type
)
15759 && part_die
->linkage_name
!= NULL
)
15763 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
15768 /* Strip any leading namespaces/classes, keep only the base name.
15769 DW_AT_name for named DIEs does not contain the prefixes. */
15770 base
= strrchr (demangled
, ':');
15771 if (base
&& base
> demangled
&& base
[-1] == ':')
15776 part_die
->name
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
15777 base
, strlen (base
));
15782 part_die
->fixup_called
= 1;
15785 /* Read an attribute value described by an attribute form. */
15787 static const gdb_byte
*
15788 read_attribute_value (const struct die_reader_specs
*reader
,
15789 struct attribute
*attr
, unsigned form
,
15790 const gdb_byte
*info_ptr
)
15792 struct dwarf2_cu
*cu
= reader
->cu
;
15793 bfd
*abfd
= reader
->abfd
;
15794 struct comp_unit_head
*cu_header
= &cu
->header
;
15795 unsigned int bytes_read
;
15796 struct dwarf_block
*blk
;
15801 case DW_FORM_ref_addr
:
15802 if (cu
->header
.version
== 2)
15803 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
15805 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
15806 &cu
->header
, &bytes_read
);
15807 info_ptr
+= bytes_read
;
15809 case DW_FORM_GNU_ref_alt
:
15810 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
15811 info_ptr
+= bytes_read
;
15814 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
15815 info_ptr
+= bytes_read
;
15817 case DW_FORM_block2
:
15818 blk
= dwarf_alloc_block (cu
);
15819 blk
->size
= read_2_bytes (abfd
, info_ptr
);
15821 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
15822 info_ptr
+= blk
->size
;
15823 DW_BLOCK (attr
) = blk
;
15825 case DW_FORM_block4
:
15826 blk
= dwarf_alloc_block (cu
);
15827 blk
->size
= read_4_bytes (abfd
, info_ptr
);
15829 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
15830 info_ptr
+= blk
->size
;
15831 DW_BLOCK (attr
) = blk
;
15833 case DW_FORM_data2
:
15834 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
15837 case DW_FORM_data4
:
15838 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
15841 case DW_FORM_data8
:
15842 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
15845 case DW_FORM_sec_offset
:
15846 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
15847 info_ptr
+= bytes_read
;
15849 case DW_FORM_string
:
15850 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
15851 DW_STRING_IS_CANONICAL (attr
) = 0;
15852 info_ptr
+= bytes_read
;
15855 if (!cu
->per_cu
->is_dwz
)
15857 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
15859 DW_STRING_IS_CANONICAL (attr
) = 0;
15860 info_ptr
+= bytes_read
;
15864 case DW_FORM_GNU_strp_alt
:
15866 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
15867 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
15870 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
15871 DW_STRING_IS_CANONICAL (attr
) = 0;
15872 info_ptr
+= bytes_read
;
15875 case DW_FORM_exprloc
:
15876 case DW_FORM_block
:
15877 blk
= dwarf_alloc_block (cu
);
15878 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15879 info_ptr
+= bytes_read
;
15880 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
15881 info_ptr
+= blk
->size
;
15882 DW_BLOCK (attr
) = blk
;
15884 case DW_FORM_block1
:
15885 blk
= dwarf_alloc_block (cu
);
15886 blk
->size
= read_1_byte (abfd
, info_ptr
);
15888 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
15889 info_ptr
+= blk
->size
;
15890 DW_BLOCK (attr
) = blk
;
15892 case DW_FORM_data1
:
15893 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
15897 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
15900 case DW_FORM_flag_present
:
15901 DW_UNSND (attr
) = 1;
15903 case DW_FORM_sdata
:
15904 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
15905 info_ptr
+= bytes_read
;
15907 case DW_FORM_udata
:
15908 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15909 info_ptr
+= bytes_read
;
15912 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
15913 + read_1_byte (abfd
, info_ptr
));
15917 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
15918 + read_2_bytes (abfd
, info_ptr
));
15922 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
15923 + read_4_bytes (abfd
, info_ptr
));
15927 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
15928 + read_8_bytes (abfd
, info_ptr
));
15931 case DW_FORM_ref_sig8
:
15932 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
15935 case DW_FORM_ref_udata
:
15936 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
15937 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
15938 info_ptr
+= bytes_read
;
15940 case DW_FORM_indirect
:
15941 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15942 info_ptr
+= bytes_read
;
15943 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
15945 case DW_FORM_GNU_addr_index
:
15946 if (reader
->dwo_file
== NULL
)
15948 /* For now flag a hard error.
15949 Later we can turn this into a complaint. */
15950 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
15951 dwarf_form_name (form
),
15952 bfd_get_filename (abfd
));
15954 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
15955 info_ptr
+= bytes_read
;
15957 case DW_FORM_GNU_str_index
:
15958 if (reader
->dwo_file
== NULL
)
15960 /* For now flag a hard error.
15961 Later we can turn this into a complaint if warranted. */
15962 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
15963 dwarf_form_name (form
),
15964 bfd_get_filename (abfd
));
15967 ULONGEST str_index
=
15968 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15970 DW_STRING (attr
) = read_str_index (reader
, str_index
);
15971 DW_STRING_IS_CANONICAL (attr
) = 0;
15972 info_ptr
+= bytes_read
;
15976 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
15977 dwarf_form_name (form
),
15978 bfd_get_filename (abfd
));
15982 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
15983 attr
->form
= DW_FORM_GNU_ref_alt
;
15985 /* We have seen instances where the compiler tried to emit a byte
15986 size attribute of -1 which ended up being encoded as an unsigned
15987 0xffffffff. Although 0xffffffff is technically a valid size value,
15988 an object of this size seems pretty unlikely so we can relatively
15989 safely treat these cases as if the size attribute was invalid and
15990 treat them as zero by default. */
15991 if (attr
->name
== DW_AT_byte_size
15992 && form
== DW_FORM_data4
15993 && DW_UNSND (attr
) >= 0xffffffff)
15996 (&symfile_complaints
,
15997 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
15998 hex_string (DW_UNSND (attr
)));
15999 DW_UNSND (attr
) = 0;
16005 /* Read an attribute described by an abbreviated attribute. */
16007 static const gdb_byte
*
16008 read_attribute (const struct die_reader_specs
*reader
,
16009 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
16010 const gdb_byte
*info_ptr
)
16012 attr
->name
= abbrev
->name
;
16013 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
16016 /* Read dwarf information from a buffer. */
16018 static unsigned int
16019 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
16021 return bfd_get_8 (abfd
, buf
);
16025 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
16027 return bfd_get_signed_8 (abfd
, buf
);
16030 static unsigned int
16031 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16033 return bfd_get_16 (abfd
, buf
);
16037 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16039 return bfd_get_signed_16 (abfd
, buf
);
16042 static unsigned int
16043 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16045 return bfd_get_32 (abfd
, buf
);
16049 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16051 return bfd_get_signed_32 (abfd
, buf
);
16055 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16057 return bfd_get_64 (abfd
, buf
);
16061 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
16062 unsigned int *bytes_read
)
16064 struct comp_unit_head
*cu_header
= &cu
->header
;
16065 CORE_ADDR retval
= 0;
16067 if (cu_header
->signed_addr_p
)
16069 switch (cu_header
->addr_size
)
16072 retval
= bfd_get_signed_16 (abfd
, buf
);
16075 retval
= bfd_get_signed_32 (abfd
, buf
);
16078 retval
= bfd_get_signed_64 (abfd
, buf
);
16081 internal_error (__FILE__
, __LINE__
,
16082 _("read_address: bad switch, signed [in module %s]"),
16083 bfd_get_filename (abfd
));
16088 switch (cu_header
->addr_size
)
16091 retval
= bfd_get_16 (abfd
, buf
);
16094 retval
= bfd_get_32 (abfd
, buf
);
16097 retval
= bfd_get_64 (abfd
, buf
);
16100 internal_error (__FILE__
, __LINE__
,
16101 _("read_address: bad switch, "
16102 "unsigned [in module %s]"),
16103 bfd_get_filename (abfd
));
16107 *bytes_read
= cu_header
->addr_size
;
16111 /* Read the initial length from a section. The (draft) DWARF 3
16112 specification allows the initial length to take up either 4 bytes
16113 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16114 bytes describe the length and all offsets will be 8 bytes in length
16117 An older, non-standard 64-bit format is also handled by this
16118 function. The older format in question stores the initial length
16119 as an 8-byte quantity without an escape value. Lengths greater
16120 than 2^32 aren't very common which means that the initial 4 bytes
16121 is almost always zero. Since a length value of zero doesn't make
16122 sense for the 32-bit format, this initial zero can be considered to
16123 be an escape value which indicates the presence of the older 64-bit
16124 format. As written, the code can't detect (old format) lengths
16125 greater than 4GB. If it becomes necessary to handle lengths
16126 somewhat larger than 4GB, we could allow other small values (such
16127 as the non-sensical values of 1, 2, and 3) to also be used as
16128 escape values indicating the presence of the old format.
16130 The value returned via bytes_read should be used to increment the
16131 relevant pointer after calling read_initial_length().
16133 [ Note: read_initial_length() and read_offset() are based on the
16134 document entitled "DWARF Debugging Information Format", revision
16135 3, draft 8, dated November 19, 2001. This document was obtained
16138 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16140 This document is only a draft and is subject to change. (So beware.)
16142 Details regarding the older, non-standard 64-bit format were
16143 determined empirically by examining 64-bit ELF files produced by
16144 the SGI toolchain on an IRIX 6.5 machine.
16146 - Kevin, July 16, 2002
16150 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
16152 LONGEST length
= bfd_get_32 (abfd
, buf
);
16154 if (length
== 0xffffffff)
16156 length
= bfd_get_64 (abfd
, buf
+ 4);
16159 else if (length
== 0)
16161 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16162 length
= bfd_get_64 (abfd
, buf
);
16173 /* Cover function for read_initial_length.
16174 Returns the length of the object at BUF, and stores the size of the
16175 initial length in *BYTES_READ and stores the size that offsets will be in
16177 If the initial length size is not equivalent to that specified in
16178 CU_HEADER then issue a complaint.
16179 This is useful when reading non-comp-unit headers. */
16182 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
16183 const struct comp_unit_head
*cu_header
,
16184 unsigned int *bytes_read
,
16185 unsigned int *offset_size
)
16187 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
16189 gdb_assert (cu_header
->initial_length_size
== 4
16190 || cu_header
->initial_length_size
== 8
16191 || cu_header
->initial_length_size
== 12);
16193 if (cu_header
->initial_length_size
!= *bytes_read
)
16194 complaint (&symfile_complaints
,
16195 _("intermixed 32-bit and 64-bit DWARF sections"));
16197 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
16201 /* Read an offset from the data stream. The size of the offset is
16202 given by cu_header->offset_size. */
16205 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
16206 const struct comp_unit_head
*cu_header
,
16207 unsigned int *bytes_read
)
16209 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
16211 *bytes_read
= cu_header
->offset_size
;
16215 /* Read an offset from the data stream. */
16218 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
16220 LONGEST retval
= 0;
16222 switch (offset_size
)
16225 retval
= bfd_get_32 (abfd
, buf
);
16228 retval
= bfd_get_64 (abfd
, buf
);
16231 internal_error (__FILE__
, __LINE__
,
16232 _("read_offset_1: bad switch [in module %s]"),
16233 bfd_get_filename (abfd
));
16239 static const gdb_byte
*
16240 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
16242 /* If the size of a host char is 8 bits, we can return a pointer
16243 to the buffer, otherwise we have to copy the data to a buffer
16244 allocated on the temporary obstack. */
16245 gdb_assert (HOST_CHAR_BIT
== 8);
16249 static const char *
16250 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
16251 unsigned int *bytes_read_ptr
)
16253 /* If the size of a host char is 8 bits, we can return a pointer
16254 to the string, otherwise we have to copy the string to a buffer
16255 allocated on the temporary obstack. */
16256 gdb_assert (HOST_CHAR_BIT
== 8);
16259 *bytes_read_ptr
= 1;
16262 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
16263 return (const char *) buf
;
16266 static const char *
16267 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
16269 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
16270 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
16271 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16272 bfd_get_filename (abfd
));
16273 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
16274 error (_("DW_FORM_strp pointing outside of "
16275 ".debug_str section [in module %s]"),
16276 bfd_get_filename (abfd
));
16277 gdb_assert (HOST_CHAR_BIT
== 8);
16278 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
16280 return (const char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
16283 /* Read a string at offset STR_OFFSET in the .debug_str section from
16284 the .dwz file DWZ. Throw an error if the offset is too large. If
16285 the string consists of a single NUL byte, return NULL; otherwise
16286 return a pointer to the string. */
16288 static const char *
16289 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
16291 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
16293 if (dwz
->str
.buffer
== NULL
)
16294 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16295 "section [in module %s]"),
16296 bfd_get_filename (dwz
->dwz_bfd
));
16297 if (str_offset
>= dwz
->str
.size
)
16298 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16299 ".debug_str section [in module %s]"),
16300 bfd_get_filename (dwz
->dwz_bfd
));
16301 gdb_assert (HOST_CHAR_BIT
== 8);
16302 if (dwz
->str
.buffer
[str_offset
] == '\0')
16304 return (const char *) (dwz
->str
.buffer
+ str_offset
);
16307 static const char *
16308 read_indirect_string (bfd
*abfd
, const gdb_byte
*buf
,
16309 const struct comp_unit_head
*cu_header
,
16310 unsigned int *bytes_read_ptr
)
16312 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
16314 return read_indirect_string_at_offset (abfd
, str_offset
);
16318 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16319 unsigned int *bytes_read_ptr
)
16322 unsigned int num_read
;
16324 unsigned char byte
;
16332 byte
= bfd_get_8 (abfd
, buf
);
16335 result
|= ((ULONGEST
) (byte
& 127) << shift
);
16336 if ((byte
& 128) == 0)
16342 *bytes_read_ptr
= num_read
;
16347 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16348 unsigned int *bytes_read_ptr
)
16351 int i
, shift
, num_read
;
16352 unsigned char byte
;
16360 byte
= bfd_get_8 (abfd
, buf
);
16363 result
|= ((LONGEST
) (byte
& 127) << shift
);
16365 if ((byte
& 128) == 0)
16370 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
16371 result
|= -(((LONGEST
) 1) << shift
);
16372 *bytes_read_ptr
= num_read
;
16376 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16377 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16378 ADDR_SIZE is the size of addresses from the CU header. */
16381 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
16383 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16384 bfd
*abfd
= objfile
->obfd
;
16385 const gdb_byte
*info_ptr
;
16387 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
16388 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
16389 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16390 objfile_name (objfile
));
16391 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
16392 error (_("DW_FORM_addr_index pointing outside of "
16393 ".debug_addr section [in module %s]"),
16394 objfile_name (objfile
));
16395 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
16396 + addr_base
+ addr_index
* addr_size
);
16397 if (addr_size
== 4)
16398 return bfd_get_32 (abfd
, info_ptr
);
16400 return bfd_get_64 (abfd
, info_ptr
);
16403 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16406 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
16408 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
16411 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16414 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
16415 unsigned int *bytes_read
)
16417 bfd
*abfd
= cu
->objfile
->obfd
;
16418 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
16420 return read_addr_index (cu
, addr_index
);
16423 /* Data structure to pass results from dwarf2_read_addr_index_reader
16424 back to dwarf2_read_addr_index. */
16426 struct dwarf2_read_addr_index_data
16428 ULONGEST addr_base
;
16432 /* die_reader_func for dwarf2_read_addr_index. */
16435 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
16436 const gdb_byte
*info_ptr
,
16437 struct die_info
*comp_unit_die
,
16441 struct dwarf2_cu
*cu
= reader
->cu
;
16442 struct dwarf2_read_addr_index_data
*aidata
=
16443 (struct dwarf2_read_addr_index_data
*) data
;
16445 aidata
->addr_base
= cu
->addr_base
;
16446 aidata
->addr_size
= cu
->header
.addr_size
;
16449 /* Given an index in .debug_addr, fetch the value.
16450 NOTE: This can be called during dwarf expression evaluation,
16451 long after the debug information has been read, and thus per_cu->cu
16452 may no longer exist. */
16455 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
16456 unsigned int addr_index
)
16458 struct objfile
*objfile
= per_cu
->objfile
;
16459 struct dwarf2_cu
*cu
= per_cu
->cu
;
16460 ULONGEST addr_base
;
16463 /* This is intended to be called from outside this file. */
16464 dw2_setup (objfile
);
16466 /* We need addr_base and addr_size.
16467 If we don't have PER_CU->cu, we have to get it.
16468 Nasty, but the alternative is storing the needed info in PER_CU,
16469 which at this point doesn't seem justified: it's not clear how frequently
16470 it would get used and it would increase the size of every PER_CU.
16471 Entry points like dwarf2_per_cu_addr_size do a similar thing
16472 so we're not in uncharted territory here.
16473 Alas we need to be a bit more complicated as addr_base is contained
16476 We don't need to read the entire CU(/TU).
16477 We just need the header and top level die.
16479 IWBN to use the aging mechanism to let us lazily later discard the CU.
16480 For now we skip this optimization. */
16484 addr_base
= cu
->addr_base
;
16485 addr_size
= cu
->header
.addr_size
;
16489 struct dwarf2_read_addr_index_data aidata
;
16491 /* Note: We can't use init_cutu_and_read_dies_simple here,
16492 we need addr_base. */
16493 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
16494 dwarf2_read_addr_index_reader
, &aidata
);
16495 addr_base
= aidata
.addr_base
;
16496 addr_size
= aidata
.addr_size
;
16499 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
16502 /* Given a DW_FORM_GNU_str_index, fetch the string.
16503 This is only used by the Fission support. */
16505 static const char *
16506 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
16508 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16509 const char *objf_name
= objfile_name (objfile
);
16510 bfd
*abfd
= objfile
->obfd
;
16511 struct dwarf2_cu
*cu
= reader
->cu
;
16512 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
16513 struct dwarf2_section_info
*str_offsets_section
=
16514 &reader
->dwo_file
->sections
.str_offsets
;
16515 const gdb_byte
*info_ptr
;
16516 ULONGEST str_offset
;
16517 static const char form_name
[] = "DW_FORM_GNU_str_index";
16519 dwarf2_read_section (objfile
, str_section
);
16520 dwarf2_read_section (objfile
, str_offsets_section
);
16521 if (str_section
->buffer
== NULL
)
16522 error (_("%s used without .debug_str.dwo section"
16523 " in CU at offset 0x%lx [in module %s]"),
16524 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16525 if (str_offsets_section
->buffer
== NULL
)
16526 error (_("%s used without .debug_str_offsets.dwo section"
16527 " in CU at offset 0x%lx [in module %s]"),
16528 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16529 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
16530 error (_("%s pointing outside of .debug_str_offsets.dwo"
16531 " section in CU at offset 0x%lx [in module %s]"),
16532 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16533 info_ptr
= (str_offsets_section
->buffer
16534 + str_index
* cu
->header
.offset_size
);
16535 if (cu
->header
.offset_size
== 4)
16536 str_offset
= bfd_get_32 (abfd
, info_ptr
);
16538 str_offset
= bfd_get_64 (abfd
, info_ptr
);
16539 if (str_offset
>= str_section
->size
)
16540 error (_("Offset from %s pointing outside of"
16541 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16542 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16543 return (const char *) (str_section
->buffer
+ str_offset
);
16546 /* Return the length of an LEB128 number in BUF. */
16549 leb128_size (const gdb_byte
*buf
)
16551 const gdb_byte
*begin
= buf
;
16557 if ((byte
& 128) == 0)
16558 return buf
- begin
;
16563 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
16571 cu
->language
= language_c
;
16573 case DW_LANG_C_plus_plus
:
16574 cu
->language
= language_cplus
;
16577 cu
->language
= language_d
;
16579 case DW_LANG_Fortran77
:
16580 case DW_LANG_Fortran90
:
16581 case DW_LANG_Fortran95
:
16582 cu
->language
= language_fortran
;
16585 cu
->language
= language_go
;
16587 case DW_LANG_Mips_Assembler
:
16588 cu
->language
= language_asm
;
16591 cu
->language
= language_java
;
16593 case DW_LANG_Ada83
:
16594 case DW_LANG_Ada95
:
16595 cu
->language
= language_ada
;
16597 case DW_LANG_Modula2
:
16598 cu
->language
= language_m2
;
16600 case DW_LANG_Pascal83
:
16601 cu
->language
= language_pascal
;
16604 cu
->language
= language_objc
;
16606 case DW_LANG_Cobol74
:
16607 case DW_LANG_Cobol85
:
16609 cu
->language
= language_minimal
;
16612 cu
->language_defn
= language_def (cu
->language
);
16615 /* Return the named attribute or NULL if not there. */
16617 static struct attribute
*
16618 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
16623 struct attribute
*spec
= NULL
;
16625 for (i
= 0; i
< die
->num_attrs
; ++i
)
16627 if (die
->attrs
[i
].name
== name
)
16628 return &die
->attrs
[i
];
16629 if (die
->attrs
[i
].name
== DW_AT_specification
16630 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
16631 spec
= &die
->attrs
[i
];
16637 die
= follow_die_ref (die
, spec
, &cu
);
16643 /* Return the named attribute or NULL if not there,
16644 but do not follow DW_AT_specification, etc.
16645 This is for use in contexts where we're reading .debug_types dies.
16646 Following DW_AT_specification, DW_AT_abstract_origin will take us
16647 back up the chain, and we want to go down. */
16649 static struct attribute
*
16650 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
16654 for (i
= 0; i
< die
->num_attrs
; ++i
)
16655 if (die
->attrs
[i
].name
== name
)
16656 return &die
->attrs
[i
];
16661 /* Return non-zero iff the attribute NAME is defined for the given DIE,
16662 and holds a non-zero value. This function should only be used for
16663 DW_FORM_flag or DW_FORM_flag_present attributes. */
16666 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
16668 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
16670 return (attr
&& DW_UNSND (attr
));
16674 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
16676 /* A DIE is a declaration if it has a DW_AT_declaration attribute
16677 which value is non-zero. However, we have to be careful with
16678 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
16679 (via dwarf2_flag_true_p) follows this attribute. So we may
16680 end up accidently finding a declaration attribute that belongs
16681 to a different DIE referenced by the specification attribute,
16682 even though the given DIE does not have a declaration attribute. */
16683 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
16684 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
16687 /* Return the die giving the specification for DIE, if there is
16688 one. *SPEC_CU is the CU containing DIE on input, and the CU
16689 containing the return value on output. If there is no
16690 specification, but there is an abstract origin, that is
16693 static struct die_info
*
16694 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
16696 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
16699 if (spec_attr
== NULL
)
16700 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
16702 if (spec_attr
== NULL
)
16705 return follow_die_ref (die
, spec_attr
, spec_cu
);
16708 /* Free the line_header structure *LH, and any arrays and strings it
16710 NOTE: This is also used as a "cleanup" function. */
16713 free_line_header (struct line_header
*lh
)
16715 if (lh
->standard_opcode_lengths
)
16716 xfree (lh
->standard_opcode_lengths
);
16718 /* Remember that all the lh->file_names[i].name pointers are
16719 pointers into debug_line_buffer, and don't need to be freed. */
16720 if (lh
->file_names
)
16721 xfree (lh
->file_names
);
16723 /* Similarly for the include directory names. */
16724 if (lh
->include_dirs
)
16725 xfree (lh
->include_dirs
);
16730 /* Add an entry to LH's include directory table. */
16733 add_include_dir (struct line_header
*lh
, const char *include_dir
)
16735 /* Grow the array if necessary. */
16736 if (lh
->include_dirs_size
== 0)
16738 lh
->include_dirs_size
= 1; /* for testing */
16739 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
16740 * sizeof (*lh
->include_dirs
));
16742 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
16744 lh
->include_dirs_size
*= 2;
16745 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
16746 (lh
->include_dirs_size
16747 * sizeof (*lh
->include_dirs
)));
16750 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
16753 /* Add an entry to LH's file name table. */
16756 add_file_name (struct line_header
*lh
,
16758 unsigned int dir_index
,
16759 unsigned int mod_time
,
16760 unsigned int length
)
16762 struct file_entry
*fe
;
16764 /* Grow the array if necessary. */
16765 if (lh
->file_names_size
== 0)
16767 lh
->file_names_size
= 1; /* for testing */
16768 lh
->file_names
= xmalloc (lh
->file_names_size
16769 * sizeof (*lh
->file_names
));
16771 else if (lh
->num_file_names
>= lh
->file_names_size
)
16773 lh
->file_names_size
*= 2;
16774 lh
->file_names
= xrealloc (lh
->file_names
,
16775 (lh
->file_names_size
16776 * sizeof (*lh
->file_names
)));
16779 fe
= &lh
->file_names
[lh
->num_file_names
++];
16781 fe
->dir_index
= dir_index
;
16782 fe
->mod_time
= mod_time
;
16783 fe
->length
= length
;
16784 fe
->included_p
= 0;
16788 /* A convenience function to find the proper .debug_line section for a
16791 static struct dwarf2_section_info
*
16792 get_debug_line_section (struct dwarf2_cu
*cu
)
16794 struct dwarf2_section_info
*section
;
16796 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
16798 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
16799 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
16800 else if (cu
->per_cu
->is_dwz
)
16802 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
16804 section
= &dwz
->line
;
16807 section
= &dwarf2_per_objfile
->line
;
16812 /* Read the statement program header starting at OFFSET in
16813 .debug_line, or .debug_line.dwo. Return a pointer
16814 to a struct line_header, allocated using xmalloc.
16816 NOTE: the strings in the include directory and file name tables of
16817 the returned object point into the dwarf line section buffer,
16818 and must not be freed. */
16820 static struct line_header
*
16821 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
16823 struct cleanup
*back_to
;
16824 struct line_header
*lh
;
16825 const gdb_byte
*line_ptr
;
16826 unsigned int bytes_read
, offset_size
;
16828 const char *cur_dir
, *cur_file
;
16829 struct dwarf2_section_info
*section
;
16832 section
= get_debug_line_section (cu
);
16833 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
16834 if (section
->buffer
== NULL
)
16836 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
16837 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
16839 complaint (&symfile_complaints
, _("missing .debug_line section"));
16843 /* We can't do this until we know the section is non-empty.
16844 Only then do we know we have such a section. */
16845 abfd
= get_section_bfd_owner (section
);
16847 /* Make sure that at least there's room for the total_length field.
16848 That could be 12 bytes long, but we're just going to fudge that. */
16849 if (offset
+ 4 >= section
->size
)
16851 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16855 lh
= xmalloc (sizeof (*lh
));
16856 memset (lh
, 0, sizeof (*lh
));
16857 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
16860 line_ptr
= section
->buffer
+ offset
;
16862 /* Read in the header. */
16864 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
16865 &bytes_read
, &offset_size
);
16866 line_ptr
+= bytes_read
;
16867 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
16869 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16870 do_cleanups (back_to
);
16873 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
16874 lh
->version
= read_2_bytes (abfd
, line_ptr
);
16876 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
16877 line_ptr
+= offset_size
;
16878 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
16880 if (lh
->version
>= 4)
16882 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
16886 lh
->maximum_ops_per_instruction
= 1;
16888 if (lh
->maximum_ops_per_instruction
== 0)
16890 lh
->maximum_ops_per_instruction
= 1;
16891 complaint (&symfile_complaints
,
16892 _("invalid maximum_ops_per_instruction "
16893 "in `.debug_line' section"));
16896 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
16898 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
16900 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
16902 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
16904 lh
->standard_opcode_lengths
16905 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
16907 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
16908 for (i
= 1; i
< lh
->opcode_base
; ++i
)
16910 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
16914 /* Read directory table. */
16915 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
16917 line_ptr
+= bytes_read
;
16918 add_include_dir (lh
, cur_dir
);
16920 line_ptr
+= bytes_read
;
16922 /* Read file name table. */
16923 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
16925 unsigned int dir_index
, mod_time
, length
;
16927 line_ptr
+= bytes_read
;
16928 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
16929 line_ptr
+= bytes_read
;
16930 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
16931 line_ptr
+= bytes_read
;
16932 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
16933 line_ptr
+= bytes_read
;
16935 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
16937 line_ptr
+= bytes_read
;
16938 lh
->statement_program_start
= line_ptr
;
16940 if (line_ptr
> (section
->buffer
+ section
->size
))
16941 complaint (&symfile_complaints
,
16942 _("line number info header doesn't "
16943 "fit in `.debug_line' section"));
16945 discard_cleanups (back_to
);
16949 /* Subroutine of dwarf_decode_lines to simplify it.
16950 Return the file name of the psymtab for included file FILE_INDEX
16951 in line header LH of PST.
16952 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
16953 If space for the result is malloc'd, it will be freed by a cleanup.
16954 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
16956 The function creates dangling cleanup registration. */
16958 static const char *
16959 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
16960 const struct partial_symtab
*pst
,
16961 const char *comp_dir
)
16963 const struct file_entry fe
= lh
->file_names
[file_index
];
16964 const char *include_name
= fe
.name
;
16965 const char *include_name_to_compare
= include_name
;
16966 const char *dir_name
= NULL
;
16967 const char *pst_filename
;
16968 char *copied_name
= NULL
;
16972 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
16974 if (!IS_ABSOLUTE_PATH (include_name
)
16975 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
16977 /* Avoid creating a duplicate psymtab for PST.
16978 We do this by comparing INCLUDE_NAME and PST_FILENAME.
16979 Before we do the comparison, however, we need to account
16980 for DIR_NAME and COMP_DIR.
16981 First prepend dir_name (if non-NULL). If we still don't
16982 have an absolute path prepend comp_dir (if non-NULL).
16983 However, the directory we record in the include-file's
16984 psymtab does not contain COMP_DIR (to match the
16985 corresponding symtab(s)).
16990 bash$ gcc -g ./hello.c
16991 include_name = "hello.c"
16993 DW_AT_comp_dir = comp_dir = "/tmp"
16994 DW_AT_name = "./hello.c" */
16996 if (dir_name
!= NULL
)
16998 char *tem
= concat (dir_name
, SLASH_STRING
,
16999 include_name
, (char *)NULL
);
17001 make_cleanup (xfree
, tem
);
17002 include_name
= tem
;
17003 include_name_to_compare
= include_name
;
17005 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
17007 char *tem
= concat (comp_dir
, SLASH_STRING
,
17008 include_name
, (char *)NULL
);
17010 make_cleanup (xfree
, tem
);
17011 include_name_to_compare
= tem
;
17015 pst_filename
= pst
->filename
;
17016 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
17018 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
17019 pst_filename
, (char *)NULL
);
17020 pst_filename
= copied_name
;
17023 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
17025 if (copied_name
!= NULL
)
17026 xfree (copied_name
);
17030 return include_name
;
17033 /* Ignore this record_line request. */
17036 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17041 /* Subroutine of dwarf_decode_lines to simplify it.
17042 Process the line number information in LH. */
17045 dwarf_decode_lines_1 (struct line_header
*lh
, const char *comp_dir
,
17046 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
17048 const gdb_byte
*line_ptr
, *extended_end
;
17049 const gdb_byte
*line_end
;
17050 unsigned int bytes_read
, extended_len
;
17051 unsigned char op_code
, extended_op
, adj_opcode
;
17052 CORE_ADDR baseaddr
;
17053 struct objfile
*objfile
= cu
->objfile
;
17054 bfd
*abfd
= objfile
->obfd
;
17055 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17056 const int decode_for_pst_p
= (pst
!= NULL
);
17057 struct subfile
*last_subfile
= NULL
;
17058 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17061 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17063 line_ptr
= lh
->statement_program_start
;
17064 line_end
= lh
->statement_program_end
;
17066 /* Read the statement sequences until there's nothing left. */
17067 while (line_ptr
< line_end
)
17069 /* state machine registers */
17070 CORE_ADDR address
= 0;
17071 unsigned int file
= 1;
17072 unsigned int line
= 1;
17073 unsigned int column
= 0;
17074 int is_stmt
= lh
->default_is_stmt
;
17075 int basic_block
= 0;
17076 int end_sequence
= 0;
17078 unsigned char op_index
= 0;
17080 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
17082 /* Start a subfile for the current file of the state machine. */
17083 /* lh->include_dirs and lh->file_names are 0-based, but the
17084 directory and file name numbers in the statement program
17086 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
17087 const char *dir
= NULL
;
17090 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17092 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
17095 /* Decode the table. */
17096 while (!end_sequence
)
17098 op_code
= read_1_byte (abfd
, line_ptr
);
17100 if (line_ptr
> line_end
)
17102 dwarf2_debug_line_missing_end_sequence_complaint ();
17106 if (op_code
>= lh
->opcode_base
)
17108 /* Special operand. */
17109 adj_opcode
= op_code
- lh
->opcode_base
;
17110 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
17111 / lh
->maximum_ops_per_instruction
)
17112 * lh
->minimum_instruction_length
);
17113 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
17114 % lh
->maximum_ops_per_instruction
);
17115 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
17116 if (lh
->num_file_names
< file
|| file
== 0)
17117 dwarf2_debug_line_missing_file_complaint ();
17118 /* For now we ignore lines not starting on an
17119 instruction boundary. */
17120 else if (op_index
== 0)
17122 lh
->file_names
[file
- 1].included_p
= 1;
17123 if (!decode_for_pst_p
&& is_stmt
)
17125 if (last_subfile
!= current_subfile
)
17127 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17129 (*p_record_line
) (last_subfile
, 0, addr
);
17130 last_subfile
= current_subfile
;
17132 /* Append row to matrix using current values. */
17133 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17134 (*p_record_line
) (current_subfile
, line
, addr
);
17139 else switch (op_code
)
17141 case DW_LNS_extended_op
:
17142 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
17144 line_ptr
+= bytes_read
;
17145 extended_end
= line_ptr
+ extended_len
;
17146 extended_op
= read_1_byte (abfd
, line_ptr
);
17148 switch (extended_op
)
17150 case DW_LNE_end_sequence
:
17151 p_record_line
= record_line
;
17154 case DW_LNE_set_address
:
17155 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
17157 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
17159 /* This line table is for a function which has been
17160 GCd by the linker. Ignore it. PR gdb/12528 */
17163 = line_ptr
- get_debug_line_section (cu
)->buffer
;
17165 complaint (&symfile_complaints
,
17166 _(".debug_line address at offset 0x%lx is 0 "
17168 line_offset
, objfile_name (objfile
));
17169 p_record_line
= noop_record_line
;
17173 line_ptr
+= bytes_read
;
17174 address
+= baseaddr
;
17176 case DW_LNE_define_file
:
17178 const char *cur_file
;
17179 unsigned int dir_index
, mod_time
, length
;
17181 cur_file
= read_direct_string (abfd
, line_ptr
,
17183 line_ptr
+= bytes_read
;
17185 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17186 line_ptr
+= bytes_read
;
17188 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17189 line_ptr
+= bytes_read
;
17191 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17192 line_ptr
+= bytes_read
;
17193 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17196 case DW_LNE_set_discriminator
:
17197 /* The discriminator is not interesting to the debugger;
17199 line_ptr
= extended_end
;
17202 complaint (&symfile_complaints
,
17203 _("mangled .debug_line section"));
17206 /* Make sure that we parsed the extended op correctly. If e.g.
17207 we expected a different address size than the producer used,
17208 we may have read the wrong number of bytes. */
17209 if (line_ptr
!= extended_end
)
17211 complaint (&symfile_complaints
,
17212 _("mangled .debug_line section"));
17217 if (lh
->num_file_names
< file
|| file
== 0)
17218 dwarf2_debug_line_missing_file_complaint ();
17221 lh
->file_names
[file
- 1].included_p
= 1;
17222 if (!decode_for_pst_p
&& is_stmt
)
17224 if (last_subfile
!= current_subfile
)
17226 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17228 (*p_record_line
) (last_subfile
, 0, addr
);
17229 last_subfile
= current_subfile
;
17231 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17232 (*p_record_line
) (current_subfile
, line
, addr
);
17237 case DW_LNS_advance_pc
:
17240 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17242 address
+= (((op_index
+ adjust
)
17243 / lh
->maximum_ops_per_instruction
)
17244 * lh
->minimum_instruction_length
);
17245 op_index
= ((op_index
+ adjust
)
17246 % lh
->maximum_ops_per_instruction
);
17247 line_ptr
+= bytes_read
;
17250 case DW_LNS_advance_line
:
17251 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
17252 line_ptr
+= bytes_read
;
17254 case DW_LNS_set_file
:
17256 /* The arrays lh->include_dirs and lh->file_names are
17257 0-based, but the directory and file name numbers in
17258 the statement program are 1-based. */
17259 struct file_entry
*fe
;
17260 const char *dir
= NULL
;
17262 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17263 line_ptr
+= bytes_read
;
17264 if (lh
->num_file_names
< file
|| file
== 0)
17265 dwarf2_debug_line_missing_file_complaint ();
17268 fe
= &lh
->file_names
[file
- 1];
17270 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17271 if (!decode_for_pst_p
)
17273 last_subfile
= current_subfile
;
17274 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
17279 case DW_LNS_set_column
:
17280 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17281 line_ptr
+= bytes_read
;
17283 case DW_LNS_negate_stmt
:
17284 is_stmt
= (!is_stmt
);
17286 case DW_LNS_set_basic_block
:
17289 /* Add to the address register of the state machine the
17290 address increment value corresponding to special opcode
17291 255. I.e., this value is scaled by the minimum
17292 instruction length since special opcode 255 would have
17293 scaled the increment. */
17294 case DW_LNS_const_add_pc
:
17296 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
17298 address
+= (((op_index
+ adjust
)
17299 / lh
->maximum_ops_per_instruction
)
17300 * lh
->minimum_instruction_length
);
17301 op_index
= ((op_index
+ adjust
)
17302 % lh
->maximum_ops_per_instruction
);
17305 case DW_LNS_fixed_advance_pc
:
17306 address
+= read_2_bytes (abfd
, line_ptr
);
17312 /* Unknown standard opcode, ignore it. */
17315 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
17317 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17318 line_ptr
+= bytes_read
;
17323 if (lh
->num_file_names
< file
|| file
== 0)
17324 dwarf2_debug_line_missing_file_complaint ();
17327 lh
->file_names
[file
- 1].included_p
= 1;
17328 if (!decode_for_pst_p
)
17330 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17331 (*p_record_line
) (current_subfile
, 0, addr
);
17337 /* Decode the Line Number Program (LNP) for the given line_header
17338 structure and CU. The actual information extracted and the type
17339 of structures created from the LNP depends on the value of PST.
17341 1. If PST is NULL, then this procedure uses the data from the program
17342 to create all necessary symbol tables, and their linetables.
17344 2. If PST is not NULL, this procedure reads the program to determine
17345 the list of files included by the unit represented by PST, and
17346 builds all the associated partial symbol tables.
17348 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17349 It is used for relative paths in the line table.
17350 NOTE: When processing partial symtabs (pst != NULL),
17351 comp_dir == pst->dirname.
17353 NOTE: It is important that psymtabs have the same file name (via strcmp)
17354 as the corresponding symtab. Since COMP_DIR is not used in the name of the
17355 symtab we don't use it in the name of the psymtabs we create.
17356 E.g. expand_line_sal requires this when finding psymtabs to expand.
17357 A good testcase for this is mb-inline.exp. */
17360 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
17361 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
17362 int want_line_info
)
17364 struct objfile
*objfile
= cu
->objfile
;
17365 const int decode_for_pst_p
= (pst
!= NULL
);
17366 struct subfile
*first_subfile
= current_subfile
;
17368 if (want_line_info
)
17369 dwarf_decode_lines_1 (lh
, comp_dir
, cu
, pst
);
17371 if (decode_for_pst_p
)
17375 /* Now that we're done scanning the Line Header Program, we can
17376 create the psymtab of each included file. */
17377 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
17378 if (lh
->file_names
[file_index
].included_p
== 1)
17380 const char *include_name
=
17381 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
17382 if (include_name
!= NULL
)
17383 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
17388 /* Make sure a symtab is created for every file, even files
17389 which contain only variables (i.e. no code with associated
17393 for (i
= 0; i
< lh
->num_file_names
; i
++)
17395 const char *dir
= NULL
;
17396 struct file_entry
*fe
;
17398 fe
= &lh
->file_names
[i
];
17400 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17401 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
17403 /* Skip the main file; we don't need it, and it must be
17404 allocated last, so that it will show up before the
17405 non-primary symtabs in the objfile's symtab list. */
17406 if (current_subfile
== first_subfile
)
17409 if (current_subfile
->symtab
== NULL
)
17410 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
17412 fe
->symtab
= current_subfile
->symtab
;
17417 /* Start a subfile for DWARF. FILENAME is the name of the file and
17418 DIRNAME the name of the source directory which contains FILENAME
17419 or NULL if not known. COMP_DIR is the compilation directory for the
17420 linetable's compilation unit or NULL if not known.
17421 This routine tries to keep line numbers from identical absolute and
17422 relative file names in a common subfile.
17424 Using the `list' example from the GDB testsuite, which resides in
17425 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
17426 of /srcdir/list0.c yields the following debugging information for list0.c:
17428 DW_AT_name: /srcdir/list0.c
17429 DW_AT_comp_dir: /compdir
17430 files.files[0].name: list0.h
17431 files.files[0].dir: /srcdir
17432 files.files[1].name: list0.c
17433 files.files[1].dir: /srcdir
17435 The line number information for list0.c has to end up in a single
17436 subfile, so that `break /srcdir/list0.c:1' works as expected.
17437 start_subfile will ensure that this happens provided that we pass the
17438 concatenation of files.files[1].dir and files.files[1].name as the
17442 dwarf2_start_subfile (const char *filename
, const char *dirname
,
17443 const char *comp_dir
)
17447 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
17448 `start_symtab' will always pass the contents of DW_AT_comp_dir as
17449 second argument to start_subfile. To be consistent, we do the
17450 same here. In order not to lose the line information directory,
17451 we concatenate it to the filename when it makes sense.
17452 Note that the Dwarf3 standard says (speaking of filenames in line
17453 information): ``The directory index is ignored for file names
17454 that represent full path names''. Thus ignoring dirname in the
17455 `else' branch below isn't an issue. */
17457 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
17459 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
17463 start_subfile (filename
, comp_dir
);
17469 /* Start a symtab for DWARF.
17470 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
17473 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
17474 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
17476 start_symtab (name
, comp_dir
, low_pc
);
17477 record_debugformat ("DWARF 2");
17478 record_producer (cu
->producer
);
17480 /* We assume that we're processing GCC output. */
17481 processing_gcc_compilation
= 2;
17483 cu
->processing_has_namespace_info
= 0;
17487 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
17488 struct dwarf2_cu
*cu
)
17490 struct objfile
*objfile
= cu
->objfile
;
17491 struct comp_unit_head
*cu_header
= &cu
->header
;
17493 /* NOTE drow/2003-01-30: There used to be a comment and some special
17494 code here to turn a symbol with DW_AT_external and a
17495 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
17496 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
17497 with some versions of binutils) where shared libraries could have
17498 relocations against symbols in their debug information - the
17499 minimal symbol would have the right address, but the debug info
17500 would not. It's no longer necessary, because we will explicitly
17501 apply relocations when we read in the debug information now. */
17503 /* A DW_AT_location attribute with no contents indicates that a
17504 variable has been optimized away. */
17505 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
17507 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
17511 /* Handle one degenerate form of location expression specially, to
17512 preserve GDB's previous behavior when section offsets are
17513 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
17514 then mark this symbol as LOC_STATIC. */
17516 if (attr_form_is_block (attr
)
17517 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
17518 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
17519 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
17520 && (DW_BLOCK (attr
)->size
17521 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
17523 unsigned int dummy
;
17525 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
17526 SYMBOL_VALUE_ADDRESS (sym
) =
17527 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
17529 SYMBOL_VALUE_ADDRESS (sym
) =
17530 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
17531 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
17532 fixup_symbol_section (sym
, objfile
);
17533 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
17534 SYMBOL_SECTION (sym
));
17538 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
17539 expression evaluator, and use LOC_COMPUTED only when necessary
17540 (i.e. when the value of a register or memory location is
17541 referenced, or a thread-local block, etc.). Then again, it might
17542 not be worthwhile. I'm assuming that it isn't unless performance
17543 or memory numbers show me otherwise. */
17545 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
17547 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
17548 cu
->has_loclist
= 1;
17551 /* Given a pointer to a DWARF information entry, figure out if we need
17552 to make a symbol table entry for it, and if so, create a new entry
17553 and return a pointer to it.
17554 If TYPE is NULL, determine symbol type from the die, otherwise
17555 used the passed type.
17556 If SPACE is not NULL, use it to hold the new symbol. If it is
17557 NULL, allocate a new symbol on the objfile's obstack. */
17559 static struct symbol
*
17560 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
17561 struct symbol
*space
)
17563 struct objfile
*objfile
= cu
->objfile
;
17564 struct symbol
*sym
= NULL
;
17566 struct attribute
*attr
= NULL
;
17567 struct attribute
*attr2
= NULL
;
17568 CORE_ADDR baseaddr
;
17569 struct pending
**list_to_add
= NULL
;
17571 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
17573 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17575 name
= dwarf2_name (die
, cu
);
17578 const char *linkagename
;
17579 int suppress_add
= 0;
17584 sym
= allocate_symbol (objfile
);
17585 OBJSTAT (objfile
, n_syms
++);
17587 /* Cache this symbol's name and the name's demangled form (if any). */
17588 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
17589 linkagename
= dwarf2_physname (name
, die
, cu
);
17590 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
17592 /* Fortran does not have mangling standard and the mangling does differ
17593 between gfortran, iFort etc. */
17594 if (cu
->language
== language_fortran
17595 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
17596 symbol_set_demangled_name (&(sym
->ginfo
),
17597 dwarf2_full_name (name
, die
, cu
),
17600 /* Default assumptions.
17601 Use the passed type or decode it from the die. */
17602 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
17603 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
17605 SYMBOL_TYPE (sym
) = type
;
17607 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
17608 attr
= dwarf2_attr (die
,
17609 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
17613 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
17616 attr
= dwarf2_attr (die
,
17617 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
17621 int file_index
= DW_UNSND (attr
);
17623 if (cu
->line_header
== NULL
17624 || file_index
> cu
->line_header
->num_file_names
)
17625 complaint (&symfile_complaints
,
17626 _("file index out of range"));
17627 else if (file_index
> 0)
17629 struct file_entry
*fe
;
17631 fe
= &cu
->line_header
->file_names
[file_index
- 1];
17632 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
17639 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
17641 SYMBOL_VALUE_ADDRESS (sym
)
17642 = attr_value_as_address (attr
) + baseaddr
;
17643 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
17644 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
17645 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
17646 add_symbol_to_list (sym
, cu
->list_in_scope
);
17648 case DW_TAG_subprogram
:
17649 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17651 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
17652 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
17653 if ((attr2
&& (DW_UNSND (attr2
) != 0))
17654 || cu
->language
== language_ada
)
17656 /* Subprograms marked external are stored as a global symbol.
17657 Ada subprograms, whether marked external or not, are always
17658 stored as a global symbol, because we want to be able to
17659 access them globally. For instance, we want to be able
17660 to break on a nested subprogram without having to
17661 specify the context. */
17662 list_to_add
= &global_symbols
;
17666 list_to_add
= cu
->list_in_scope
;
17669 case DW_TAG_inlined_subroutine
:
17670 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17672 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
17673 SYMBOL_INLINED (sym
) = 1;
17674 list_to_add
= cu
->list_in_scope
;
17676 case DW_TAG_template_value_param
:
17678 /* Fall through. */
17679 case DW_TAG_constant
:
17680 case DW_TAG_variable
:
17681 case DW_TAG_member
:
17682 /* Compilation with minimal debug info may result in
17683 variables with missing type entries. Change the
17684 misleading `void' type to something sensible. */
17685 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
17687 = objfile_type (objfile
)->nodebug_data_symbol
;
17689 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
17690 /* In the case of DW_TAG_member, we should only be called for
17691 static const members. */
17692 if (die
->tag
== DW_TAG_member
)
17694 /* dwarf2_add_field uses die_is_declaration,
17695 so we do the same. */
17696 gdb_assert (die_is_declaration (die
, cu
));
17701 dwarf2_const_value (attr
, sym
, cu
);
17702 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
17705 if (attr2
&& (DW_UNSND (attr2
) != 0))
17706 list_to_add
= &global_symbols
;
17708 list_to_add
= cu
->list_in_scope
;
17712 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
17715 var_decode_location (attr
, sym
, cu
);
17716 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
17718 /* Fortran explicitly imports any global symbols to the local
17719 scope by DW_TAG_common_block. */
17720 if (cu
->language
== language_fortran
&& die
->parent
17721 && die
->parent
->tag
== DW_TAG_common_block
)
17724 if (SYMBOL_CLASS (sym
) == LOC_STATIC
17725 && SYMBOL_VALUE_ADDRESS (sym
) == 0
17726 && !dwarf2_per_objfile
->has_section_at_zero
)
17728 /* When a static variable is eliminated by the linker,
17729 the corresponding debug information is not stripped
17730 out, but the variable address is set to null;
17731 do not add such variables into symbol table. */
17733 else if (attr2
&& (DW_UNSND (attr2
) != 0))
17735 /* Workaround gfortran PR debug/40040 - it uses
17736 DW_AT_location for variables in -fPIC libraries which may
17737 get overriden by other libraries/executable and get
17738 a different address. Resolve it by the minimal symbol
17739 which may come from inferior's executable using copy
17740 relocation. Make this workaround only for gfortran as for
17741 other compilers GDB cannot guess the minimal symbol
17742 Fortran mangling kind. */
17743 if (cu
->language
== language_fortran
&& die
->parent
17744 && die
->parent
->tag
== DW_TAG_module
17746 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
17747 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
17749 /* A variable with DW_AT_external is never static,
17750 but it may be block-scoped. */
17751 list_to_add
= (cu
->list_in_scope
== &file_symbols
17752 ? &global_symbols
: cu
->list_in_scope
);
17755 list_to_add
= cu
->list_in_scope
;
17759 /* We do not know the address of this symbol.
17760 If it is an external symbol and we have type information
17761 for it, enter the symbol as a LOC_UNRESOLVED symbol.
17762 The address of the variable will then be determined from
17763 the minimal symbol table whenever the variable is
17765 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
17767 /* Fortran explicitly imports any global symbols to the local
17768 scope by DW_TAG_common_block. */
17769 if (cu
->language
== language_fortran
&& die
->parent
17770 && die
->parent
->tag
== DW_TAG_common_block
)
17772 /* SYMBOL_CLASS doesn't matter here because
17773 read_common_block is going to reset it. */
17775 list_to_add
= cu
->list_in_scope
;
17777 else if (attr2
&& (DW_UNSND (attr2
) != 0)
17778 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
17780 /* A variable with DW_AT_external is never static, but it
17781 may be block-scoped. */
17782 list_to_add
= (cu
->list_in_scope
== &file_symbols
17783 ? &global_symbols
: cu
->list_in_scope
);
17785 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
17787 else if (!die_is_declaration (die
, cu
))
17789 /* Use the default LOC_OPTIMIZED_OUT class. */
17790 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
17792 list_to_add
= cu
->list_in_scope
;
17796 case DW_TAG_formal_parameter
:
17797 /* If we are inside a function, mark this as an argument. If
17798 not, we might be looking at an argument to an inlined function
17799 when we do not have enough information to show inlined frames;
17800 pretend it's a local variable in that case so that the user can
17802 if (context_stack_depth
> 0
17803 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
17804 SYMBOL_IS_ARGUMENT (sym
) = 1;
17805 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
17808 var_decode_location (attr
, sym
, cu
);
17810 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
17813 dwarf2_const_value (attr
, sym
, cu
);
17816 list_to_add
= cu
->list_in_scope
;
17818 case DW_TAG_unspecified_parameters
:
17819 /* From varargs functions; gdb doesn't seem to have any
17820 interest in this information, so just ignore it for now.
17823 case DW_TAG_template_type_param
:
17825 /* Fall through. */
17826 case DW_TAG_class_type
:
17827 case DW_TAG_interface_type
:
17828 case DW_TAG_structure_type
:
17829 case DW_TAG_union_type
:
17830 case DW_TAG_set_type
:
17831 case DW_TAG_enumeration_type
:
17832 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
17833 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
17836 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
17837 really ever be static objects: otherwise, if you try
17838 to, say, break of a class's method and you're in a file
17839 which doesn't mention that class, it won't work unless
17840 the check for all static symbols in lookup_symbol_aux
17841 saves you. See the OtherFileClass tests in
17842 gdb.c++/namespace.exp. */
17846 list_to_add
= (cu
->list_in_scope
== &file_symbols
17847 && (cu
->language
== language_cplus
17848 || cu
->language
== language_java
)
17849 ? &global_symbols
: cu
->list_in_scope
);
17851 /* The semantics of C++ state that "struct foo {
17852 ... }" also defines a typedef for "foo". A Java
17853 class declaration also defines a typedef for the
17855 if (cu
->language
== language_cplus
17856 || cu
->language
== language_java
17857 || cu
->language
== language_ada
)
17859 /* The symbol's name is already allocated along
17860 with this objfile, so we don't need to
17861 duplicate it for the type. */
17862 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
17863 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
17868 case DW_TAG_typedef
:
17869 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
17870 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
17871 list_to_add
= cu
->list_in_scope
;
17873 case DW_TAG_base_type
:
17874 case DW_TAG_subrange_type
:
17875 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
17876 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
17877 list_to_add
= cu
->list_in_scope
;
17879 case DW_TAG_enumerator
:
17880 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
17883 dwarf2_const_value (attr
, sym
, cu
);
17886 /* NOTE: carlton/2003-11-10: See comment above in the
17887 DW_TAG_class_type, etc. block. */
17889 list_to_add
= (cu
->list_in_scope
== &file_symbols
17890 && (cu
->language
== language_cplus
17891 || cu
->language
== language_java
)
17892 ? &global_symbols
: cu
->list_in_scope
);
17895 case DW_TAG_imported_declaration
:
17896 case DW_TAG_namespace
:
17897 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
17898 list_to_add
= &global_symbols
;
17900 case DW_TAG_module
:
17901 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
17902 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
17903 list_to_add
= &global_symbols
;
17905 case DW_TAG_common_block
:
17906 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
17907 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
17908 add_symbol_to_list (sym
, cu
->list_in_scope
);
17911 /* Not a tag we recognize. Hopefully we aren't processing
17912 trash data, but since we must specifically ignore things
17913 we don't recognize, there is nothing else we should do at
17915 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
17916 dwarf_tag_name (die
->tag
));
17922 sym
->hash_next
= objfile
->template_symbols
;
17923 objfile
->template_symbols
= sym
;
17924 list_to_add
= NULL
;
17927 if (list_to_add
!= NULL
)
17928 add_symbol_to_list (sym
, list_to_add
);
17930 /* For the benefit of old versions of GCC, check for anonymous
17931 namespaces based on the demangled name. */
17932 if (!cu
->processing_has_namespace_info
17933 && cu
->language
== language_cplus
)
17934 cp_scan_for_anonymous_namespaces (sym
, objfile
);
17939 /* A wrapper for new_symbol_full that always allocates a new symbol. */
17941 static struct symbol
*
17942 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
17944 return new_symbol_full (die
, type
, cu
, NULL
);
17947 /* Given an attr with a DW_FORM_dataN value in host byte order,
17948 zero-extend it as appropriate for the symbol's type. The DWARF
17949 standard (v4) is not entirely clear about the meaning of using
17950 DW_FORM_dataN for a constant with a signed type, where the type is
17951 wider than the data. The conclusion of a discussion on the DWARF
17952 list was that this is unspecified. We choose to always zero-extend
17953 because that is the interpretation long in use by GCC. */
17956 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
17957 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
17959 struct objfile
*objfile
= cu
->objfile
;
17960 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
17961 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
17962 LONGEST l
= DW_UNSND (attr
);
17964 if (bits
< sizeof (*value
) * 8)
17966 l
&= ((LONGEST
) 1 << bits
) - 1;
17969 else if (bits
== sizeof (*value
) * 8)
17973 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
17974 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
17981 /* Read a constant value from an attribute. Either set *VALUE, or if
17982 the value does not fit in *VALUE, set *BYTES - either already
17983 allocated on the objfile obstack, or newly allocated on OBSTACK,
17984 or, set *BATON, if we translated the constant to a location
17988 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
17989 const char *name
, struct obstack
*obstack
,
17990 struct dwarf2_cu
*cu
,
17991 LONGEST
*value
, const gdb_byte
**bytes
,
17992 struct dwarf2_locexpr_baton
**baton
)
17994 struct objfile
*objfile
= cu
->objfile
;
17995 struct comp_unit_head
*cu_header
= &cu
->header
;
17996 struct dwarf_block
*blk
;
17997 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
17998 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
18004 switch (attr
->form
)
18007 case DW_FORM_GNU_addr_index
:
18011 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
18012 dwarf2_const_value_length_mismatch_complaint (name
,
18013 cu_header
->addr_size
,
18014 TYPE_LENGTH (type
));
18015 /* Symbols of this form are reasonably rare, so we just
18016 piggyback on the existing location code rather than writing
18017 a new implementation of symbol_computed_ops. */
18018 *baton
= obstack_alloc (obstack
, sizeof (struct dwarf2_locexpr_baton
));
18019 (*baton
)->per_cu
= cu
->per_cu
;
18020 gdb_assert ((*baton
)->per_cu
);
18022 (*baton
)->size
= 2 + cu_header
->addr_size
;
18023 data
= obstack_alloc (obstack
, (*baton
)->size
);
18024 (*baton
)->data
= data
;
18026 data
[0] = DW_OP_addr
;
18027 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
18028 byte_order
, DW_ADDR (attr
));
18029 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
18032 case DW_FORM_string
:
18034 case DW_FORM_GNU_str_index
:
18035 case DW_FORM_GNU_strp_alt
:
18036 /* DW_STRING is already allocated on the objfile obstack, point
18038 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
18040 case DW_FORM_block1
:
18041 case DW_FORM_block2
:
18042 case DW_FORM_block4
:
18043 case DW_FORM_block
:
18044 case DW_FORM_exprloc
:
18045 blk
= DW_BLOCK (attr
);
18046 if (TYPE_LENGTH (type
) != blk
->size
)
18047 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
18048 TYPE_LENGTH (type
));
18049 *bytes
= blk
->data
;
18052 /* The DW_AT_const_value attributes are supposed to carry the
18053 symbol's value "represented as it would be on the target
18054 architecture." By the time we get here, it's already been
18055 converted to host endianness, so we just need to sign- or
18056 zero-extend it as appropriate. */
18057 case DW_FORM_data1
:
18058 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
18060 case DW_FORM_data2
:
18061 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
18063 case DW_FORM_data4
:
18064 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
18066 case DW_FORM_data8
:
18067 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
18070 case DW_FORM_sdata
:
18071 *value
= DW_SND (attr
);
18074 case DW_FORM_udata
:
18075 *value
= DW_UNSND (attr
);
18079 complaint (&symfile_complaints
,
18080 _("unsupported const value attribute form: '%s'"),
18081 dwarf_form_name (attr
->form
));
18088 /* Copy constant value from an attribute to a symbol. */
18091 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
18092 struct dwarf2_cu
*cu
)
18094 struct objfile
*objfile
= cu
->objfile
;
18095 struct comp_unit_head
*cu_header
= &cu
->header
;
18097 const gdb_byte
*bytes
;
18098 struct dwarf2_locexpr_baton
*baton
;
18100 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
18101 SYMBOL_PRINT_NAME (sym
),
18102 &objfile
->objfile_obstack
, cu
,
18103 &value
, &bytes
, &baton
);
18107 SYMBOL_LOCATION_BATON (sym
) = baton
;
18108 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
18110 else if (bytes
!= NULL
)
18112 SYMBOL_VALUE_BYTES (sym
) = bytes
;
18113 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
18117 SYMBOL_VALUE (sym
) = value
;
18118 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
18122 /* Return the type of the die in question using its DW_AT_type attribute. */
18124 static struct type
*
18125 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18127 struct attribute
*type_attr
;
18129 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
18132 /* A missing DW_AT_type represents a void type. */
18133 return objfile_type (cu
->objfile
)->builtin_void
;
18136 return lookup_die_type (die
, type_attr
, cu
);
18139 /* True iff CU's producer generates GNAT Ada auxiliary information
18140 that allows to find parallel types through that information instead
18141 of having to do expensive parallel lookups by type name. */
18144 need_gnat_info (struct dwarf2_cu
*cu
)
18146 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18147 of GNAT produces this auxiliary information, without any indication
18148 that it is produced. Part of enhancing the FSF version of GNAT
18149 to produce that information will be to put in place an indicator
18150 that we can use in order to determine whether the descriptive type
18151 info is available or not. One suggestion that has been made is
18152 to use a new attribute, attached to the CU die. For now, assume
18153 that the descriptive type info is not available. */
18157 /* Return the auxiliary type of the die in question using its
18158 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18159 attribute is not present. */
18161 static struct type
*
18162 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18164 struct attribute
*type_attr
;
18166 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
18170 return lookup_die_type (die
, type_attr
, cu
);
18173 /* If DIE has a descriptive_type attribute, then set the TYPE's
18174 descriptive type accordingly. */
18177 set_descriptive_type (struct type
*type
, struct die_info
*die
,
18178 struct dwarf2_cu
*cu
)
18180 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
18182 if (descriptive_type
)
18184 ALLOCATE_GNAT_AUX_TYPE (type
);
18185 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
18189 /* Return the containing type of the die in question using its
18190 DW_AT_containing_type attribute. */
18192 static struct type
*
18193 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18195 struct attribute
*type_attr
;
18197 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
18199 error (_("Dwarf Error: Problem turning containing type into gdb type "
18200 "[in module %s]"), objfile_name (cu
->objfile
));
18202 return lookup_die_type (die
, type_attr
, cu
);
18205 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18207 static struct type
*
18208 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
18210 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18211 char *message
, *saved
;
18213 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18214 objfile_name (objfile
),
18215 cu
->header
.offset
.sect_off
,
18216 die
->offset
.sect_off
);
18217 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
18218 message
, strlen (message
));
18221 return init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
18224 /* Look up the type of DIE in CU using its type attribute ATTR.
18225 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18226 DW_AT_containing_type.
18227 If there is no type substitute an error marker. */
18229 static struct type
*
18230 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
18231 struct dwarf2_cu
*cu
)
18233 struct objfile
*objfile
= cu
->objfile
;
18234 struct type
*this_type
;
18236 gdb_assert (attr
->name
== DW_AT_type
18237 || attr
->name
== DW_AT_GNAT_descriptive_type
18238 || attr
->name
== DW_AT_containing_type
);
18240 /* First see if we have it cached. */
18242 if (attr
->form
== DW_FORM_GNU_ref_alt
)
18244 struct dwarf2_per_cu_data
*per_cu
;
18245 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18247 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
18248 this_type
= get_die_type_at_offset (offset
, per_cu
);
18250 else if (attr_form_is_ref (attr
))
18252 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18254 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
18256 else if (attr
->form
== DW_FORM_ref_sig8
)
18258 ULONGEST signature
= DW_SIGNATURE (attr
);
18260 return get_signatured_type (die
, signature
, cu
);
18264 complaint (&symfile_complaints
,
18265 _("Dwarf Error: Bad type attribute %s in DIE"
18266 " at 0x%x [in module %s]"),
18267 dwarf_attr_name (attr
->name
), die
->offset
.sect_off
,
18268 objfile_name (objfile
));
18269 return build_error_marker_type (cu
, die
);
18272 /* If not cached we need to read it in. */
18274 if (this_type
== NULL
)
18276 struct die_info
*type_die
= NULL
;
18277 struct dwarf2_cu
*type_cu
= cu
;
18279 if (attr_form_is_ref (attr
))
18280 type_die
= follow_die_ref (die
, attr
, &type_cu
);
18281 if (type_die
== NULL
)
18282 return build_error_marker_type (cu
, die
);
18283 /* If we find the type now, it's probably because the type came
18284 from an inter-CU reference and the type's CU got expanded before
18286 this_type
= read_type_die (type_die
, type_cu
);
18289 /* If we still don't have a type use an error marker. */
18291 if (this_type
== NULL
)
18292 return build_error_marker_type (cu
, die
);
18297 /* Return the type in DIE, CU.
18298 Returns NULL for invalid types.
18300 This first does a lookup in die_type_hash,
18301 and only reads the die in if necessary.
18303 NOTE: This can be called when reading in partial or full symbols. */
18305 static struct type
*
18306 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
18308 struct type
*this_type
;
18310 this_type
= get_die_type (die
, cu
);
18314 return read_type_die_1 (die
, cu
);
18317 /* Read the type in DIE, CU.
18318 Returns NULL for invalid types. */
18320 static struct type
*
18321 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
18323 struct type
*this_type
= NULL
;
18327 case DW_TAG_class_type
:
18328 case DW_TAG_interface_type
:
18329 case DW_TAG_structure_type
:
18330 case DW_TAG_union_type
:
18331 this_type
= read_structure_type (die
, cu
);
18333 case DW_TAG_enumeration_type
:
18334 this_type
= read_enumeration_type (die
, cu
);
18336 case DW_TAG_subprogram
:
18337 case DW_TAG_subroutine_type
:
18338 case DW_TAG_inlined_subroutine
:
18339 this_type
= read_subroutine_type (die
, cu
);
18341 case DW_TAG_array_type
:
18342 this_type
= read_array_type (die
, cu
);
18344 case DW_TAG_set_type
:
18345 this_type
= read_set_type (die
, cu
);
18347 case DW_TAG_pointer_type
:
18348 this_type
= read_tag_pointer_type (die
, cu
);
18350 case DW_TAG_ptr_to_member_type
:
18351 this_type
= read_tag_ptr_to_member_type (die
, cu
);
18353 case DW_TAG_reference_type
:
18354 this_type
= read_tag_reference_type (die
, cu
);
18356 case DW_TAG_const_type
:
18357 this_type
= read_tag_const_type (die
, cu
);
18359 case DW_TAG_volatile_type
:
18360 this_type
= read_tag_volatile_type (die
, cu
);
18362 case DW_TAG_restrict_type
:
18363 this_type
= read_tag_restrict_type (die
, cu
);
18365 case DW_TAG_string_type
:
18366 this_type
= read_tag_string_type (die
, cu
);
18368 case DW_TAG_typedef
:
18369 this_type
= read_typedef (die
, cu
);
18371 case DW_TAG_subrange_type
:
18372 this_type
= read_subrange_type (die
, cu
);
18374 case DW_TAG_base_type
:
18375 this_type
= read_base_type (die
, cu
);
18377 case DW_TAG_unspecified_type
:
18378 this_type
= read_unspecified_type (die
, cu
);
18380 case DW_TAG_namespace
:
18381 this_type
= read_namespace_type (die
, cu
);
18383 case DW_TAG_module
:
18384 this_type
= read_module_type (die
, cu
);
18387 complaint (&symfile_complaints
,
18388 _("unexpected tag in read_type_die: '%s'"),
18389 dwarf_tag_name (die
->tag
));
18396 /* See if we can figure out if the class lives in a namespace. We do
18397 this by looking for a member function; its demangled name will
18398 contain namespace info, if there is any.
18399 Return the computed name or NULL.
18400 Space for the result is allocated on the objfile's obstack.
18401 This is the full-die version of guess_partial_die_structure_name.
18402 In this case we know DIE has no useful parent. */
18405 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
18407 struct die_info
*spec_die
;
18408 struct dwarf2_cu
*spec_cu
;
18409 struct die_info
*child
;
18412 spec_die
= die_specification (die
, &spec_cu
);
18413 if (spec_die
!= NULL
)
18419 for (child
= die
->child
;
18421 child
= child
->sibling
)
18423 if (child
->tag
== DW_TAG_subprogram
)
18425 struct attribute
*attr
;
18427 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
18429 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
18433 = language_class_name_from_physname (cu
->language_defn
,
18437 if (actual_name
!= NULL
)
18439 const char *die_name
= dwarf2_name (die
, cu
);
18441 if (die_name
!= NULL
18442 && strcmp (die_name
, actual_name
) != 0)
18444 /* Strip off the class name from the full name.
18445 We want the prefix. */
18446 int die_name_len
= strlen (die_name
);
18447 int actual_name_len
= strlen (actual_name
);
18449 /* Test for '::' as a sanity check. */
18450 if (actual_name_len
> die_name_len
+ 2
18451 && actual_name
[actual_name_len
18452 - die_name_len
- 1] == ':')
18454 obstack_copy0 (&cu
->objfile
->objfile_obstack
,
18456 actual_name_len
- die_name_len
- 2);
18459 xfree (actual_name
);
18468 /* GCC might emit a nameless typedef that has a linkage name. Determine the
18469 prefix part in such case. See
18470 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18473 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
18475 struct attribute
*attr
;
18478 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
18479 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
18482 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
18483 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
18486 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
18488 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
18489 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
18492 /* dwarf2_name had to be already called. */
18493 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
18495 /* Strip the base name, keep any leading namespaces/classes. */
18496 base
= strrchr (DW_STRING (attr
), ':');
18497 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
18500 return obstack_copy0 (&cu
->objfile
->objfile_obstack
,
18501 DW_STRING (attr
), &base
[-1] - DW_STRING (attr
));
18504 /* Return the name of the namespace/class that DIE is defined within,
18505 or "" if we can't tell. The caller should not xfree the result.
18507 For example, if we're within the method foo() in the following
18517 then determine_prefix on foo's die will return "N::C". */
18519 static const char *
18520 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
18522 struct die_info
*parent
, *spec_die
;
18523 struct dwarf2_cu
*spec_cu
;
18524 struct type
*parent_type
;
18527 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
18528 && cu
->language
!= language_fortran
)
18531 retval
= anonymous_struct_prefix (die
, cu
);
18535 /* We have to be careful in the presence of DW_AT_specification.
18536 For example, with GCC 3.4, given the code
18540 // Definition of N::foo.
18544 then we'll have a tree of DIEs like this:
18546 1: DW_TAG_compile_unit
18547 2: DW_TAG_namespace // N
18548 3: DW_TAG_subprogram // declaration of N::foo
18549 4: DW_TAG_subprogram // definition of N::foo
18550 DW_AT_specification // refers to die #3
18552 Thus, when processing die #4, we have to pretend that we're in
18553 the context of its DW_AT_specification, namely the contex of die
18556 spec_die
= die_specification (die
, &spec_cu
);
18557 if (spec_die
== NULL
)
18558 parent
= die
->parent
;
18561 parent
= spec_die
->parent
;
18565 if (parent
== NULL
)
18567 else if (parent
->building_fullname
)
18570 const char *parent_name
;
18572 /* It has been seen on RealView 2.2 built binaries,
18573 DW_TAG_template_type_param types actually _defined_ as
18574 children of the parent class:
18577 template class <class Enum> Class{};
18578 Class<enum E> class_e;
18580 1: DW_TAG_class_type (Class)
18581 2: DW_TAG_enumeration_type (E)
18582 3: DW_TAG_enumerator (enum1:0)
18583 3: DW_TAG_enumerator (enum2:1)
18585 2: DW_TAG_template_type_param
18586 DW_AT_type DW_FORM_ref_udata (E)
18588 Besides being broken debug info, it can put GDB into an
18589 infinite loop. Consider:
18591 When we're building the full name for Class<E>, we'll start
18592 at Class, and go look over its template type parameters,
18593 finding E. We'll then try to build the full name of E, and
18594 reach here. We're now trying to build the full name of E,
18595 and look over the parent DIE for containing scope. In the
18596 broken case, if we followed the parent DIE of E, we'd again
18597 find Class, and once again go look at its template type
18598 arguments, etc., etc. Simply don't consider such parent die
18599 as source-level parent of this die (it can't be, the language
18600 doesn't allow it), and break the loop here. */
18601 name
= dwarf2_name (die
, cu
);
18602 parent_name
= dwarf2_name (parent
, cu
);
18603 complaint (&symfile_complaints
,
18604 _("template param type '%s' defined within parent '%s'"),
18605 name
? name
: "<unknown>",
18606 parent_name
? parent_name
: "<unknown>");
18610 switch (parent
->tag
)
18612 case DW_TAG_namespace
:
18613 parent_type
= read_type_die (parent
, cu
);
18614 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
18615 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
18616 Work around this problem here. */
18617 if (cu
->language
== language_cplus
18618 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
18620 /* We give a name to even anonymous namespaces. */
18621 return TYPE_TAG_NAME (parent_type
);
18622 case DW_TAG_class_type
:
18623 case DW_TAG_interface_type
:
18624 case DW_TAG_structure_type
:
18625 case DW_TAG_union_type
:
18626 case DW_TAG_module
:
18627 parent_type
= read_type_die (parent
, cu
);
18628 if (TYPE_TAG_NAME (parent_type
) != NULL
)
18629 return TYPE_TAG_NAME (parent_type
);
18631 /* An anonymous structure is only allowed non-static data
18632 members; no typedefs, no member functions, et cetera.
18633 So it does not need a prefix. */
18635 case DW_TAG_compile_unit
:
18636 case DW_TAG_partial_unit
:
18637 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
18638 if (cu
->language
== language_cplus
18639 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
18640 && die
->child
!= NULL
18641 && (die
->tag
== DW_TAG_class_type
18642 || die
->tag
== DW_TAG_structure_type
18643 || die
->tag
== DW_TAG_union_type
))
18645 char *name
= guess_full_die_structure_name (die
, cu
);
18651 return determine_prefix (parent
, cu
);
18655 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
18656 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
18657 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
18658 an obconcat, otherwise allocate storage for the result. The CU argument is
18659 used to determine the language and hence, the appropriate separator. */
18661 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
18664 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
18665 int physname
, struct dwarf2_cu
*cu
)
18667 const char *lead
= "";
18670 if (suffix
== NULL
|| suffix
[0] == '\0'
18671 || prefix
== NULL
|| prefix
[0] == '\0')
18673 else if (cu
->language
== language_java
)
18675 else if (cu
->language
== language_fortran
&& physname
)
18677 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
18678 DW_AT_MIPS_linkage_name is preferred and used instead. */
18686 if (prefix
== NULL
)
18688 if (suffix
== NULL
)
18694 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
18696 strcpy (retval
, lead
);
18697 strcat (retval
, prefix
);
18698 strcat (retval
, sep
);
18699 strcat (retval
, suffix
);
18704 /* We have an obstack. */
18705 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
18709 /* Return sibling of die, NULL if no sibling. */
18711 static struct die_info
*
18712 sibling_die (struct die_info
*die
)
18714 return die
->sibling
;
18717 /* Get name of a die, return NULL if not found. */
18719 static const char *
18720 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
18721 struct obstack
*obstack
)
18723 if (name
&& cu
->language
== language_cplus
)
18725 char *canon_name
= cp_canonicalize_string (name
);
18727 if (canon_name
!= NULL
)
18729 if (strcmp (canon_name
, name
) != 0)
18730 name
= obstack_copy0 (obstack
, canon_name
, strlen (canon_name
));
18731 xfree (canon_name
);
18738 /* Get name of a die, return NULL if not found. */
18740 static const char *
18741 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
18743 struct attribute
*attr
;
18745 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
18746 if ((!attr
|| !DW_STRING (attr
))
18747 && die
->tag
!= DW_TAG_class_type
18748 && die
->tag
!= DW_TAG_interface_type
18749 && die
->tag
!= DW_TAG_structure_type
18750 && die
->tag
!= DW_TAG_union_type
)
18755 case DW_TAG_compile_unit
:
18756 case DW_TAG_partial_unit
:
18757 /* Compilation units have a DW_AT_name that is a filename, not
18758 a source language identifier. */
18759 case DW_TAG_enumeration_type
:
18760 case DW_TAG_enumerator
:
18761 /* These tags always have simple identifiers already; no need
18762 to canonicalize them. */
18763 return DW_STRING (attr
);
18765 case DW_TAG_subprogram
:
18766 /* Java constructors will all be named "<init>", so return
18767 the class name when we see this special case. */
18768 if (cu
->language
== language_java
18769 && DW_STRING (attr
) != NULL
18770 && strcmp (DW_STRING (attr
), "<init>") == 0)
18772 struct dwarf2_cu
*spec_cu
= cu
;
18773 struct die_info
*spec_die
;
18775 /* GCJ will output '<init>' for Java constructor names.
18776 For this special case, return the name of the parent class. */
18778 /* GCJ may output suprogram DIEs with AT_specification set.
18779 If so, use the name of the specified DIE. */
18780 spec_die
= die_specification (die
, &spec_cu
);
18781 if (spec_die
!= NULL
)
18782 return dwarf2_name (spec_die
, spec_cu
);
18787 if (die
->tag
== DW_TAG_class_type
)
18788 return dwarf2_name (die
, cu
);
18790 while (die
->tag
!= DW_TAG_compile_unit
18791 && die
->tag
!= DW_TAG_partial_unit
);
18795 case DW_TAG_class_type
:
18796 case DW_TAG_interface_type
:
18797 case DW_TAG_structure_type
:
18798 case DW_TAG_union_type
:
18799 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
18800 structures or unions. These were of the form "._%d" in GCC 4.1,
18801 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
18802 and GCC 4.4. We work around this problem by ignoring these. */
18803 if (attr
&& DW_STRING (attr
)
18804 && (strncmp (DW_STRING (attr
), "._", 2) == 0
18805 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
18808 /* GCC might emit a nameless typedef that has a linkage name. See
18809 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18810 if (!attr
|| DW_STRING (attr
) == NULL
)
18812 char *demangled
= NULL
;
18814 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
18816 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
18818 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
18821 /* Avoid demangling DW_STRING (attr) the second time on a second
18822 call for the same DIE. */
18823 if (!DW_STRING_IS_CANONICAL (attr
))
18824 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
18830 /* FIXME: we already did this for the partial symbol... */
18831 DW_STRING (attr
) = obstack_copy0 (&cu
->objfile
->objfile_obstack
,
18832 demangled
, strlen (demangled
));
18833 DW_STRING_IS_CANONICAL (attr
) = 1;
18836 /* Strip any leading namespaces/classes, keep only the base name.
18837 DW_AT_name for named DIEs does not contain the prefixes. */
18838 base
= strrchr (DW_STRING (attr
), ':');
18839 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
18842 return DW_STRING (attr
);
18851 if (!DW_STRING_IS_CANONICAL (attr
))
18854 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
18855 &cu
->objfile
->objfile_obstack
);
18856 DW_STRING_IS_CANONICAL (attr
) = 1;
18858 return DW_STRING (attr
);
18861 /* Return the die that this die in an extension of, or NULL if there
18862 is none. *EXT_CU is the CU containing DIE on input, and the CU
18863 containing the return value on output. */
18865 static struct die_info
*
18866 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
18868 struct attribute
*attr
;
18870 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
18874 return follow_die_ref (die
, attr
, ext_cu
);
18877 /* Convert a DIE tag into its string name. */
18879 static const char *
18880 dwarf_tag_name (unsigned tag
)
18882 const char *name
= get_DW_TAG_name (tag
);
18885 return "DW_TAG_<unknown>";
18890 /* Convert a DWARF attribute code into its string name. */
18892 static const char *
18893 dwarf_attr_name (unsigned attr
)
18897 #ifdef MIPS /* collides with DW_AT_HP_block_index */
18898 if (attr
== DW_AT_MIPS_fde
)
18899 return "DW_AT_MIPS_fde";
18901 if (attr
== DW_AT_HP_block_index
)
18902 return "DW_AT_HP_block_index";
18905 name
= get_DW_AT_name (attr
);
18908 return "DW_AT_<unknown>";
18913 /* Convert a DWARF value form code into its string name. */
18915 static const char *
18916 dwarf_form_name (unsigned form
)
18918 const char *name
= get_DW_FORM_name (form
);
18921 return "DW_FORM_<unknown>";
18927 dwarf_bool_name (unsigned mybool
)
18935 /* Convert a DWARF type code into its string name. */
18937 static const char *
18938 dwarf_type_encoding_name (unsigned enc
)
18940 const char *name
= get_DW_ATE_name (enc
);
18943 return "DW_ATE_<unknown>";
18949 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
18953 print_spaces (indent
, f
);
18954 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
18955 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
18957 if (die
->parent
!= NULL
)
18959 print_spaces (indent
, f
);
18960 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
18961 die
->parent
->offset
.sect_off
);
18964 print_spaces (indent
, f
);
18965 fprintf_unfiltered (f
, " has children: %s\n",
18966 dwarf_bool_name (die
->child
!= NULL
));
18968 print_spaces (indent
, f
);
18969 fprintf_unfiltered (f
, " attributes:\n");
18971 for (i
= 0; i
< die
->num_attrs
; ++i
)
18973 print_spaces (indent
, f
);
18974 fprintf_unfiltered (f
, " %s (%s) ",
18975 dwarf_attr_name (die
->attrs
[i
].name
),
18976 dwarf_form_name (die
->attrs
[i
].form
));
18978 switch (die
->attrs
[i
].form
)
18981 case DW_FORM_GNU_addr_index
:
18982 fprintf_unfiltered (f
, "address: ");
18983 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
18985 case DW_FORM_block2
:
18986 case DW_FORM_block4
:
18987 case DW_FORM_block
:
18988 case DW_FORM_block1
:
18989 fprintf_unfiltered (f
, "block: size %s",
18990 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
18992 case DW_FORM_exprloc
:
18993 fprintf_unfiltered (f
, "expression: size %s",
18994 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
18996 case DW_FORM_ref_addr
:
18997 fprintf_unfiltered (f
, "ref address: ");
18998 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19000 case DW_FORM_GNU_ref_alt
:
19001 fprintf_unfiltered (f
, "alt ref address: ");
19002 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19008 case DW_FORM_ref_udata
:
19009 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
19010 (long) (DW_UNSND (&die
->attrs
[i
])));
19012 case DW_FORM_data1
:
19013 case DW_FORM_data2
:
19014 case DW_FORM_data4
:
19015 case DW_FORM_data8
:
19016 case DW_FORM_udata
:
19017 case DW_FORM_sdata
:
19018 fprintf_unfiltered (f
, "constant: %s",
19019 pulongest (DW_UNSND (&die
->attrs
[i
])));
19021 case DW_FORM_sec_offset
:
19022 fprintf_unfiltered (f
, "section offset: %s",
19023 pulongest (DW_UNSND (&die
->attrs
[i
])));
19025 case DW_FORM_ref_sig8
:
19026 fprintf_unfiltered (f
, "signature: %s",
19027 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
19029 case DW_FORM_string
:
19031 case DW_FORM_GNU_str_index
:
19032 case DW_FORM_GNU_strp_alt
:
19033 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
19034 DW_STRING (&die
->attrs
[i
])
19035 ? DW_STRING (&die
->attrs
[i
]) : "",
19036 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
19039 if (DW_UNSND (&die
->attrs
[i
]))
19040 fprintf_unfiltered (f
, "flag: TRUE");
19042 fprintf_unfiltered (f
, "flag: FALSE");
19044 case DW_FORM_flag_present
:
19045 fprintf_unfiltered (f
, "flag: TRUE");
19047 case DW_FORM_indirect
:
19048 /* The reader will have reduced the indirect form to
19049 the "base form" so this form should not occur. */
19050 fprintf_unfiltered (f
,
19051 "unexpected attribute form: DW_FORM_indirect");
19054 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
19055 die
->attrs
[i
].form
);
19058 fprintf_unfiltered (f
, "\n");
19063 dump_die_for_error (struct die_info
*die
)
19065 dump_die_shallow (gdb_stderr
, 0, die
);
19069 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
19071 int indent
= level
* 4;
19073 gdb_assert (die
!= NULL
);
19075 if (level
>= max_level
)
19078 dump_die_shallow (f
, indent
, die
);
19080 if (die
->child
!= NULL
)
19082 print_spaces (indent
, f
);
19083 fprintf_unfiltered (f
, " Children:");
19084 if (level
+ 1 < max_level
)
19086 fprintf_unfiltered (f
, "\n");
19087 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
19091 fprintf_unfiltered (f
,
19092 " [not printed, max nesting level reached]\n");
19096 if (die
->sibling
!= NULL
&& level
> 0)
19098 dump_die_1 (f
, level
, max_level
, die
->sibling
);
19102 /* This is called from the pdie macro in gdbinit.in.
19103 It's not static so gcc will keep a copy callable from gdb. */
19106 dump_die (struct die_info
*die
, int max_level
)
19108 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
19112 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
19116 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
19122 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19126 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
19128 sect_offset retval
= { DW_UNSND (attr
) };
19130 if (attr_form_is_ref (attr
))
19133 retval
.sect_off
= 0;
19134 complaint (&symfile_complaints
,
19135 _("unsupported die ref attribute form: '%s'"),
19136 dwarf_form_name (attr
->form
));
19140 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19141 * the value held by the attribute is not constant. */
19144 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
19146 if (attr
->form
== DW_FORM_sdata
)
19147 return DW_SND (attr
);
19148 else if (attr
->form
== DW_FORM_udata
19149 || attr
->form
== DW_FORM_data1
19150 || attr
->form
== DW_FORM_data2
19151 || attr
->form
== DW_FORM_data4
19152 || attr
->form
== DW_FORM_data8
)
19153 return DW_UNSND (attr
);
19156 complaint (&symfile_complaints
,
19157 _("Attribute value is not a constant (%s)"),
19158 dwarf_form_name (attr
->form
));
19159 return default_value
;
19163 /* Follow reference or signature attribute ATTR of SRC_DIE.
19164 On entry *REF_CU is the CU of SRC_DIE.
19165 On exit *REF_CU is the CU of the result. */
19167 static struct die_info
*
19168 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
19169 struct dwarf2_cu
**ref_cu
)
19171 struct die_info
*die
;
19173 if (attr_form_is_ref (attr
))
19174 die
= follow_die_ref (src_die
, attr
, ref_cu
);
19175 else if (attr
->form
== DW_FORM_ref_sig8
)
19176 die
= follow_die_sig (src_die
, attr
, ref_cu
);
19179 dump_die_for_error (src_die
);
19180 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19181 objfile_name ((*ref_cu
)->objfile
));
19187 /* Follow reference OFFSET.
19188 On entry *REF_CU is the CU of the source die referencing OFFSET.
19189 On exit *REF_CU is the CU of the result.
19190 Returns NULL if OFFSET is invalid. */
19192 static struct die_info
*
19193 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
19194 struct dwarf2_cu
**ref_cu
)
19196 struct die_info temp_die
;
19197 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
19199 gdb_assert (cu
->per_cu
!= NULL
);
19203 if (cu
->per_cu
->is_debug_types
)
19205 /* .debug_types CUs cannot reference anything outside their CU.
19206 If they need to, they have to reference a signatured type via
19207 DW_FORM_ref_sig8. */
19208 if (! offset_in_cu_p (&cu
->header
, offset
))
19211 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
19212 || ! offset_in_cu_p (&cu
->header
, offset
))
19214 struct dwarf2_per_cu_data
*per_cu
;
19216 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
19219 /* If necessary, add it to the queue and load its DIEs. */
19220 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
19221 load_full_comp_unit (per_cu
, cu
->language
);
19223 target_cu
= per_cu
->cu
;
19225 else if (cu
->dies
== NULL
)
19227 /* We're loading full DIEs during partial symbol reading. */
19228 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
19229 load_full_comp_unit (cu
->per_cu
, language_minimal
);
19232 *ref_cu
= target_cu
;
19233 temp_die
.offset
= offset
;
19234 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
19237 /* Follow reference attribute ATTR of SRC_DIE.
19238 On entry *REF_CU is the CU of SRC_DIE.
19239 On exit *REF_CU is the CU of the result. */
19241 static struct die_info
*
19242 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
19243 struct dwarf2_cu
**ref_cu
)
19245 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
19246 struct dwarf2_cu
*cu
= *ref_cu
;
19247 struct die_info
*die
;
19249 die
= follow_die_offset (offset
,
19250 (attr
->form
== DW_FORM_GNU_ref_alt
19251 || cu
->per_cu
->is_dwz
),
19254 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19255 "at 0x%x [in module %s]"),
19256 offset
.sect_off
, src_die
->offset
.sect_off
,
19257 objfile_name (cu
->objfile
));
19262 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19263 Returned value is intended for DW_OP_call*. Returned
19264 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19266 struct dwarf2_locexpr_baton
19267 dwarf2_fetch_die_loc_sect_off (sect_offset offset
,
19268 struct dwarf2_per_cu_data
*per_cu
,
19269 CORE_ADDR (*get_frame_pc
) (void *baton
),
19272 struct dwarf2_cu
*cu
;
19273 struct die_info
*die
;
19274 struct attribute
*attr
;
19275 struct dwarf2_locexpr_baton retval
;
19277 dw2_setup (per_cu
->objfile
);
19279 if (per_cu
->cu
== NULL
)
19283 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
19285 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19286 offset
.sect_off
, objfile_name (per_cu
->objfile
));
19288 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
19291 /* DWARF: "If there is no such attribute, then there is no effect.".
19292 DATA is ignored if SIZE is 0. */
19294 retval
.data
= NULL
;
19297 else if (attr_form_is_section_offset (attr
))
19299 struct dwarf2_loclist_baton loclist_baton
;
19300 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
19303 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
19305 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
19307 retval
.size
= size
;
19311 if (!attr_form_is_block (attr
))
19312 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
19313 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
19314 offset
.sect_off
, objfile_name (per_cu
->objfile
));
19316 retval
.data
= DW_BLOCK (attr
)->data
;
19317 retval
.size
= DW_BLOCK (attr
)->size
;
19319 retval
.per_cu
= cu
->per_cu
;
19321 age_cached_comp_units ();
19326 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
19329 struct dwarf2_locexpr_baton
19330 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
19331 struct dwarf2_per_cu_data
*per_cu
,
19332 CORE_ADDR (*get_frame_pc
) (void *baton
),
19335 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
19337 return dwarf2_fetch_die_loc_sect_off (offset
, per_cu
, get_frame_pc
, baton
);
19340 /* Write a constant of a given type as target-ordered bytes into
19343 static const gdb_byte
*
19344 write_constant_as_bytes (struct obstack
*obstack
,
19345 enum bfd_endian byte_order
,
19352 *len
= TYPE_LENGTH (type
);
19353 result
= obstack_alloc (obstack
, *len
);
19354 store_unsigned_integer (result
, *len
, byte_order
, value
);
19359 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
19360 pointer to the constant bytes and set LEN to the length of the
19361 data. If memory is needed, allocate it on OBSTACK. If the DIE
19362 does not have a DW_AT_const_value, return NULL. */
19365 dwarf2_fetch_constant_bytes (sect_offset offset
,
19366 struct dwarf2_per_cu_data
*per_cu
,
19367 struct obstack
*obstack
,
19370 struct dwarf2_cu
*cu
;
19371 struct die_info
*die
;
19372 struct attribute
*attr
;
19373 const gdb_byte
*result
= NULL
;
19376 enum bfd_endian byte_order
;
19378 dw2_setup (per_cu
->objfile
);
19380 if (per_cu
->cu
== NULL
)
19384 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
19386 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19387 offset
.sect_off
, objfile_name (per_cu
->objfile
));
19390 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
19394 byte_order
= (bfd_big_endian (per_cu
->objfile
->obfd
)
19395 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
19397 switch (attr
->form
)
19400 case DW_FORM_GNU_addr_index
:
19404 *len
= cu
->header
.addr_size
;
19405 tem
= obstack_alloc (obstack
, *len
);
19406 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
19410 case DW_FORM_string
:
19412 case DW_FORM_GNU_str_index
:
19413 case DW_FORM_GNU_strp_alt
:
19414 /* DW_STRING is already allocated on the objfile obstack, point
19416 result
= (const gdb_byte
*) DW_STRING (attr
);
19417 *len
= strlen (DW_STRING (attr
));
19419 case DW_FORM_block1
:
19420 case DW_FORM_block2
:
19421 case DW_FORM_block4
:
19422 case DW_FORM_block
:
19423 case DW_FORM_exprloc
:
19424 result
= DW_BLOCK (attr
)->data
;
19425 *len
= DW_BLOCK (attr
)->size
;
19428 /* The DW_AT_const_value attributes are supposed to carry the
19429 symbol's value "represented as it would be on the target
19430 architecture." By the time we get here, it's already been
19431 converted to host endianness, so we just need to sign- or
19432 zero-extend it as appropriate. */
19433 case DW_FORM_data1
:
19434 type
= die_type (die
, cu
);
19435 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
19436 if (result
== NULL
)
19437 result
= write_constant_as_bytes (obstack
, byte_order
,
19440 case DW_FORM_data2
:
19441 type
= die_type (die
, cu
);
19442 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
19443 if (result
== NULL
)
19444 result
= write_constant_as_bytes (obstack
, byte_order
,
19447 case DW_FORM_data4
:
19448 type
= die_type (die
, cu
);
19449 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
19450 if (result
== NULL
)
19451 result
= write_constant_as_bytes (obstack
, byte_order
,
19454 case DW_FORM_data8
:
19455 type
= die_type (die
, cu
);
19456 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
19457 if (result
== NULL
)
19458 result
= write_constant_as_bytes (obstack
, byte_order
,
19462 case DW_FORM_sdata
:
19463 type
= die_type (die
, cu
);
19464 result
= write_constant_as_bytes (obstack
, byte_order
,
19465 type
, DW_SND (attr
), len
);
19468 case DW_FORM_udata
:
19469 type
= die_type (die
, cu
);
19470 result
= write_constant_as_bytes (obstack
, byte_order
,
19471 type
, DW_UNSND (attr
), len
);
19475 complaint (&symfile_complaints
,
19476 _("unsupported const value attribute form: '%s'"),
19477 dwarf_form_name (attr
->form
));
19484 /* Return the type of the DIE at DIE_OFFSET in the CU named by
19488 dwarf2_get_die_type (cu_offset die_offset
,
19489 struct dwarf2_per_cu_data
*per_cu
)
19491 sect_offset die_offset_sect
;
19493 dw2_setup (per_cu
->objfile
);
19495 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
19496 return get_die_type_at_offset (die_offset_sect
, per_cu
);
19499 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
19500 On entry *REF_CU is the CU of SRC_DIE.
19501 On exit *REF_CU is the CU of the result.
19502 Returns NULL if the referenced DIE isn't found. */
19504 static struct die_info
*
19505 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
19506 struct dwarf2_cu
**ref_cu
)
19508 struct objfile
*objfile
= (*ref_cu
)->objfile
;
19509 struct die_info temp_die
;
19510 struct dwarf2_cu
*sig_cu
;
19511 struct die_info
*die
;
19513 /* While it might be nice to assert sig_type->type == NULL here,
19514 we can get here for DW_AT_imported_declaration where we need
19515 the DIE not the type. */
19517 /* If necessary, add it to the queue and load its DIEs. */
19519 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
19520 read_signatured_type (sig_type
);
19522 sig_cu
= sig_type
->per_cu
.cu
;
19523 gdb_assert (sig_cu
!= NULL
);
19524 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
19525 temp_die
.offset
= sig_type
->type_offset_in_section
;
19526 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
19527 temp_die
.offset
.sect_off
);
19530 /* For .gdb_index version 7 keep track of included TUs.
19531 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
19532 if (dwarf2_per_objfile
->index_table
!= NULL
19533 && dwarf2_per_objfile
->index_table
->version
<= 7)
19535 VEC_safe_push (dwarf2_per_cu_ptr
,
19536 (*ref_cu
)->per_cu
->imported_symtabs
,
19547 /* Follow signatured type referenced by ATTR in SRC_DIE.
19548 On entry *REF_CU is the CU of SRC_DIE.
19549 On exit *REF_CU is the CU of the result.
19550 The result is the DIE of the type.
19551 If the referenced type cannot be found an error is thrown. */
19553 static struct die_info
*
19554 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
19555 struct dwarf2_cu
**ref_cu
)
19557 ULONGEST signature
= DW_SIGNATURE (attr
);
19558 struct signatured_type
*sig_type
;
19559 struct die_info
*die
;
19561 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
19563 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
19564 /* sig_type will be NULL if the signatured type is missing from
19566 if (sig_type
== NULL
)
19568 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
19569 " from DIE at 0x%x [in module %s]"),
19570 hex_string (signature
), src_die
->offset
.sect_off
,
19571 objfile_name ((*ref_cu
)->objfile
));
19574 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
19577 dump_die_for_error (src_die
);
19578 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
19579 " from DIE at 0x%x [in module %s]"),
19580 hex_string (signature
), src_die
->offset
.sect_off
,
19581 objfile_name ((*ref_cu
)->objfile
));
19587 /* Get the type specified by SIGNATURE referenced in DIE/CU,
19588 reading in and processing the type unit if necessary. */
19590 static struct type
*
19591 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
19592 struct dwarf2_cu
*cu
)
19594 struct signatured_type
*sig_type
;
19595 struct dwarf2_cu
*type_cu
;
19596 struct die_info
*type_die
;
19599 sig_type
= lookup_signatured_type (cu
, signature
);
19600 /* sig_type will be NULL if the signatured type is missing from
19602 if (sig_type
== NULL
)
19604 complaint (&symfile_complaints
,
19605 _("Dwarf Error: Cannot find signatured DIE %s referenced"
19606 " from DIE at 0x%x [in module %s]"),
19607 hex_string (signature
), die
->offset
.sect_off
,
19608 objfile_name (dwarf2_per_objfile
->objfile
));
19609 return build_error_marker_type (cu
, die
);
19612 /* If we already know the type we're done. */
19613 if (sig_type
->type
!= NULL
)
19614 return sig_type
->type
;
19617 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
19618 if (type_die
!= NULL
)
19620 /* N.B. We need to call get_die_type to ensure only one type for this DIE
19621 is created. This is important, for example, because for c++ classes
19622 we need TYPE_NAME set which is only done by new_symbol. Blech. */
19623 type
= read_type_die (type_die
, type_cu
);
19626 complaint (&symfile_complaints
,
19627 _("Dwarf Error: Cannot build signatured type %s"
19628 " referenced from DIE at 0x%x [in module %s]"),
19629 hex_string (signature
), die
->offset
.sect_off
,
19630 objfile_name (dwarf2_per_objfile
->objfile
));
19631 type
= build_error_marker_type (cu
, die
);
19636 complaint (&symfile_complaints
,
19637 _("Dwarf Error: Problem reading signatured DIE %s referenced"
19638 " from DIE at 0x%x [in module %s]"),
19639 hex_string (signature
), die
->offset
.sect_off
,
19640 objfile_name (dwarf2_per_objfile
->objfile
));
19641 type
= build_error_marker_type (cu
, die
);
19643 sig_type
->type
= type
;
19648 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
19649 reading in and processing the type unit if necessary. */
19651 static struct type
*
19652 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
19653 struct dwarf2_cu
*cu
) /* ARI: editCase function */
19655 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
19656 if (attr_form_is_ref (attr
))
19658 struct dwarf2_cu
*type_cu
= cu
;
19659 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
19661 return read_type_die (type_die
, type_cu
);
19663 else if (attr
->form
== DW_FORM_ref_sig8
)
19665 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
19669 complaint (&symfile_complaints
,
19670 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
19671 " at 0x%x [in module %s]"),
19672 dwarf_form_name (attr
->form
), die
->offset
.sect_off
,
19673 objfile_name (dwarf2_per_objfile
->objfile
));
19674 return build_error_marker_type (cu
, die
);
19678 /* Load the DIEs associated with type unit PER_CU into memory. */
19681 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
19683 struct signatured_type
*sig_type
;
19685 /* Caller is responsible for ensuring type_unit_groups don't get here. */
19686 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
19688 /* We have the per_cu, but we need the signatured_type.
19689 Fortunately this is an easy translation. */
19690 gdb_assert (per_cu
->is_debug_types
);
19691 sig_type
= (struct signatured_type
*) per_cu
;
19693 gdb_assert (per_cu
->cu
== NULL
);
19695 read_signatured_type (sig_type
);
19697 gdb_assert (per_cu
->cu
!= NULL
);
19700 /* die_reader_func for read_signatured_type.
19701 This is identical to load_full_comp_unit_reader,
19702 but is kept separate for now. */
19705 read_signatured_type_reader (const struct die_reader_specs
*reader
,
19706 const gdb_byte
*info_ptr
,
19707 struct die_info
*comp_unit_die
,
19711 struct dwarf2_cu
*cu
= reader
->cu
;
19713 gdb_assert (cu
->die_hash
== NULL
);
19715 htab_create_alloc_ex (cu
->header
.length
/ 12,
19719 &cu
->comp_unit_obstack
,
19720 hashtab_obstack_allocate
,
19721 dummy_obstack_deallocate
);
19724 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
19725 &info_ptr
, comp_unit_die
);
19726 cu
->dies
= comp_unit_die
;
19727 /* comp_unit_die is not stored in die_hash, no need. */
19729 /* We try not to read any attributes in this function, because not
19730 all CUs needed for references have been loaded yet, and symbol
19731 table processing isn't initialized. But we have to set the CU language,
19732 or we won't be able to build types correctly.
19733 Similarly, if we do not read the producer, we can not apply
19734 producer-specific interpretation. */
19735 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
19738 /* Read in a signatured type and build its CU and DIEs.
19739 If the type is a stub for the real type in a DWO file,
19740 read in the real type from the DWO file as well. */
19743 read_signatured_type (struct signatured_type
*sig_type
)
19745 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
19747 gdb_assert (per_cu
->is_debug_types
);
19748 gdb_assert (per_cu
->cu
== NULL
);
19750 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
19751 read_signatured_type_reader
, NULL
);
19752 sig_type
->per_cu
.tu_read
= 1;
19755 /* Decode simple location descriptions.
19756 Given a pointer to a dwarf block that defines a location, compute
19757 the location and return the value.
19759 NOTE drow/2003-11-18: This function is called in two situations
19760 now: for the address of static or global variables (partial symbols
19761 only) and for offsets into structures which are expected to be
19762 (more or less) constant. The partial symbol case should go away,
19763 and only the constant case should remain. That will let this
19764 function complain more accurately. A few special modes are allowed
19765 without complaint for global variables (for instance, global
19766 register values and thread-local values).
19768 A location description containing no operations indicates that the
19769 object is optimized out. The return value is 0 for that case.
19770 FIXME drow/2003-11-16: No callers check for this case any more; soon all
19771 callers will only want a very basic result and this can become a
19774 Note that stack[0] is unused except as a default error return. */
19777 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
19779 struct objfile
*objfile
= cu
->objfile
;
19781 size_t size
= blk
->size
;
19782 const gdb_byte
*data
= blk
->data
;
19783 CORE_ADDR stack
[64];
19785 unsigned int bytes_read
, unsnd
;
19791 stack
[++stacki
] = 0;
19830 stack
[++stacki
] = op
- DW_OP_lit0
;
19865 stack
[++stacki
] = op
- DW_OP_reg0
;
19867 dwarf2_complex_location_expr_complaint ();
19871 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
19873 stack
[++stacki
] = unsnd
;
19875 dwarf2_complex_location_expr_complaint ();
19879 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
19884 case DW_OP_const1u
:
19885 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
19889 case DW_OP_const1s
:
19890 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
19894 case DW_OP_const2u
:
19895 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
19899 case DW_OP_const2s
:
19900 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
19904 case DW_OP_const4u
:
19905 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
19909 case DW_OP_const4s
:
19910 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
19914 case DW_OP_const8u
:
19915 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
19920 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
19926 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
19931 stack
[stacki
+ 1] = stack
[stacki
];
19936 stack
[stacki
- 1] += stack
[stacki
];
19940 case DW_OP_plus_uconst
:
19941 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
19947 stack
[stacki
- 1] -= stack
[stacki
];
19952 /* If we're not the last op, then we definitely can't encode
19953 this using GDB's address_class enum. This is valid for partial
19954 global symbols, although the variable's address will be bogus
19957 dwarf2_complex_location_expr_complaint ();
19960 case DW_OP_GNU_push_tls_address
:
19961 /* The top of the stack has the offset from the beginning
19962 of the thread control block at which the variable is located. */
19963 /* Nothing should follow this operator, so the top of stack would
19965 /* This is valid for partial global symbols, but the variable's
19966 address will be bogus in the psymtab. Make it always at least
19967 non-zero to not look as a variable garbage collected by linker
19968 which have DW_OP_addr 0. */
19970 dwarf2_complex_location_expr_complaint ();
19974 case DW_OP_GNU_uninit
:
19977 case DW_OP_GNU_addr_index
:
19978 case DW_OP_GNU_const_index
:
19979 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
19986 const char *name
= get_DW_OP_name (op
);
19989 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
19992 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
19996 return (stack
[stacki
]);
19999 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20000 outside of the allocated space. Also enforce minimum>0. */
20001 if (stacki
>= ARRAY_SIZE (stack
) - 1)
20003 complaint (&symfile_complaints
,
20004 _("location description stack overflow"));
20010 complaint (&symfile_complaints
,
20011 _("location description stack underflow"));
20015 return (stack
[stacki
]);
20018 /* memory allocation interface */
20020 static struct dwarf_block
*
20021 dwarf_alloc_block (struct dwarf2_cu
*cu
)
20023 struct dwarf_block
*blk
;
20025 blk
= (struct dwarf_block
*)
20026 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
20030 static struct die_info
*
20031 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
20033 struct die_info
*die
;
20034 size_t size
= sizeof (struct die_info
);
20037 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
20039 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
20040 memset (die
, 0, sizeof (struct die_info
));
20045 /* Macro support. */
20047 /* Return file name relative to the compilation directory of file number I in
20048 *LH's file name table. The result is allocated using xmalloc; the caller is
20049 responsible for freeing it. */
20052 file_file_name (int file
, struct line_header
*lh
)
20054 /* Is the file number a valid index into the line header's file name
20055 table? Remember that file numbers start with one, not zero. */
20056 if (1 <= file
&& file
<= lh
->num_file_names
)
20058 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
20060 if (IS_ABSOLUTE_PATH (fe
->name
) || fe
->dir_index
== 0)
20061 return xstrdup (fe
->name
);
20062 return concat (lh
->include_dirs
[fe
->dir_index
- 1], SLASH_STRING
,
20067 /* The compiler produced a bogus file number. We can at least
20068 record the macro definitions made in the file, even if we
20069 won't be able to find the file by name. */
20070 char fake_name
[80];
20072 xsnprintf (fake_name
, sizeof (fake_name
),
20073 "<bad macro file number %d>", file
);
20075 complaint (&symfile_complaints
,
20076 _("bad file number in macro information (%d)"),
20079 return xstrdup (fake_name
);
20083 /* Return the full name of file number I in *LH's file name table.
20084 Use COMP_DIR as the name of the current directory of the
20085 compilation. The result is allocated using xmalloc; the caller is
20086 responsible for freeing it. */
20088 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
20090 /* Is the file number a valid index into the line header's file name
20091 table? Remember that file numbers start with one, not zero. */
20092 if (1 <= file
&& file
<= lh
->num_file_names
)
20094 char *relative
= file_file_name (file
, lh
);
20096 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
20098 return reconcat (relative
, comp_dir
, SLASH_STRING
, relative
, NULL
);
20101 return file_file_name (file
, lh
);
20105 static struct macro_source_file
*
20106 macro_start_file (int file
, int line
,
20107 struct macro_source_file
*current_file
,
20108 const char *comp_dir
,
20109 struct line_header
*lh
, struct objfile
*objfile
)
20111 /* File name relative to the compilation directory of this source file. */
20112 char *file_name
= file_file_name (file
, lh
);
20114 if (! current_file
)
20116 /* Note: We don't create a macro table for this compilation unit
20117 at all until we actually get a filename. */
20118 struct macro_table
*macro_table
= get_macro_table (objfile
, comp_dir
);
20120 /* If we have no current file, then this must be the start_file
20121 directive for the compilation unit's main source file. */
20122 current_file
= macro_set_main (macro_table
, file_name
);
20123 macro_define_special (macro_table
);
20126 current_file
= macro_include (current_file
, line
, file_name
);
20130 return current_file
;
20134 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20135 followed by a null byte. */
20137 copy_string (const char *buf
, int len
)
20139 char *s
= xmalloc (len
+ 1);
20141 memcpy (s
, buf
, len
);
20147 static const char *
20148 consume_improper_spaces (const char *p
, const char *body
)
20152 complaint (&symfile_complaints
,
20153 _("macro definition contains spaces "
20154 "in formal argument list:\n`%s'"),
20166 parse_macro_definition (struct macro_source_file
*file
, int line
,
20171 /* The body string takes one of two forms. For object-like macro
20172 definitions, it should be:
20174 <macro name> " " <definition>
20176 For function-like macro definitions, it should be:
20178 <macro name> "() " <definition>
20180 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20182 Spaces may appear only where explicitly indicated, and in the
20185 The Dwarf 2 spec says that an object-like macro's name is always
20186 followed by a space, but versions of GCC around March 2002 omit
20187 the space when the macro's definition is the empty string.
20189 The Dwarf 2 spec says that there should be no spaces between the
20190 formal arguments in a function-like macro's formal argument list,
20191 but versions of GCC around March 2002 include spaces after the
20195 /* Find the extent of the macro name. The macro name is terminated
20196 by either a space or null character (for an object-like macro) or
20197 an opening paren (for a function-like macro). */
20198 for (p
= body
; *p
; p
++)
20199 if (*p
== ' ' || *p
== '(')
20202 if (*p
== ' ' || *p
== '\0')
20204 /* It's an object-like macro. */
20205 int name_len
= p
- body
;
20206 char *name
= copy_string (body
, name_len
);
20207 const char *replacement
;
20210 replacement
= body
+ name_len
+ 1;
20213 dwarf2_macro_malformed_definition_complaint (body
);
20214 replacement
= body
+ name_len
;
20217 macro_define_object (file
, line
, name
, replacement
);
20221 else if (*p
== '(')
20223 /* It's a function-like macro. */
20224 char *name
= copy_string (body
, p
- body
);
20227 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
20231 p
= consume_improper_spaces (p
, body
);
20233 /* Parse the formal argument list. */
20234 while (*p
&& *p
!= ')')
20236 /* Find the extent of the current argument name. */
20237 const char *arg_start
= p
;
20239 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
20242 if (! *p
|| p
== arg_start
)
20243 dwarf2_macro_malformed_definition_complaint (body
);
20246 /* Make sure argv has room for the new argument. */
20247 if (argc
>= argv_size
)
20250 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
20253 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
20256 p
= consume_improper_spaces (p
, body
);
20258 /* Consume the comma, if present. */
20263 p
= consume_improper_spaces (p
, body
);
20272 /* Perfectly formed definition, no complaints. */
20273 macro_define_function (file
, line
, name
,
20274 argc
, (const char **) argv
,
20276 else if (*p
== '\0')
20278 /* Complain, but do define it. */
20279 dwarf2_macro_malformed_definition_complaint (body
);
20280 macro_define_function (file
, line
, name
,
20281 argc
, (const char **) argv
,
20285 /* Just complain. */
20286 dwarf2_macro_malformed_definition_complaint (body
);
20289 /* Just complain. */
20290 dwarf2_macro_malformed_definition_complaint (body
);
20296 for (i
= 0; i
< argc
; i
++)
20302 dwarf2_macro_malformed_definition_complaint (body
);
20305 /* Skip some bytes from BYTES according to the form given in FORM.
20306 Returns the new pointer. */
20308 static const gdb_byte
*
20309 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
20310 enum dwarf_form form
,
20311 unsigned int offset_size
,
20312 struct dwarf2_section_info
*section
)
20314 unsigned int bytes_read
;
20318 case DW_FORM_data1
:
20323 case DW_FORM_data2
:
20327 case DW_FORM_data4
:
20331 case DW_FORM_data8
:
20335 case DW_FORM_string
:
20336 read_direct_string (abfd
, bytes
, &bytes_read
);
20337 bytes
+= bytes_read
;
20340 case DW_FORM_sec_offset
:
20342 case DW_FORM_GNU_strp_alt
:
20343 bytes
+= offset_size
;
20346 case DW_FORM_block
:
20347 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
20348 bytes
+= bytes_read
;
20351 case DW_FORM_block1
:
20352 bytes
+= 1 + read_1_byte (abfd
, bytes
);
20354 case DW_FORM_block2
:
20355 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
20357 case DW_FORM_block4
:
20358 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
20361 case DW_FORM_sdata
:
20362 case DW_FORM_udata
:
20363 case DW_FORM_GNU_addr_index
:
20364 case DW_FORM_GNU_str_index
:
20365 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
20368 dwarf2_section_buffer_overflow_complaint (section
);
20376 complaint (&symfile_complaints
,
20377 _("invalid form 0x%x in `%s'"),
20378 form
, get_section_name (section
));
20386 /* A helper for dwarf_decode_macros that handles skipping an unknown
20387 opcode. Returns an updated pointer to the macro data buffer; or,
20388 on error, issues a complaint and returns NULL. */
20390 static const gdb_byte
*
20391 skip_unknown_opcode (unsigned int opcode
,
20392 const gdb_byte
**opcode_definitions
,
20393 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
20395 unsigned int offset_size
,
20396 struct dwarf2_section_info
*section
)
20398 unsigned int bytes_read
, i
;
20400 const gdb_byte
*defn
;
20402 if (opcode_definitions
[opcode
] == NULL
)
20404 complaint (&symfile_complaints
,
20405 _("unrecognized DW_MACFINO opcode 0x%x"),
20410 defn
= opcode_definitions
[opcode
];
20411 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
20412 defn
+= bytes_read
;
20414 for (i
= 0; i
< arg
; ++i
)
20416 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
, defn
[i
], offset_size
,
20418 if (mac_ptr
== NULL
)
20420 /* skip_form_bytes already issued the complaint. */
20428 /* A helper function which parses the header of a macro section.
20429 If the macro section is the extended (for now called "GNU") type,
20430 then this updates *OFFSET_SIZE. Returns a pointer to just after
20431 the header, or issues a complaint and returns NULL on error. */
20433 static const gdb_byte
*
20434 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
20436 const gdb_byte
*mac_ptr
,
20437 unsigned int *offset_size
,
20438 int section_is_gnu
)
20440 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
20442 if (section_is_gnu
)
20444 unsigned int version
, flags
;
20446 version
= read_2_bytes (abfd
, mac_ptr
);
20449 complaint (&symfile_complaints
,
20450 _("unrecognized version `%d' in .debug_macro section"),
20456 flags
= read_1_byte (abfd
, mac_ptr
);
20458 *offset_size
= (flags
& 1) ? 8 : 4;
20460 if ((flags
& 2) != 0)
20461 /* We don't need the line table offset. */
20462 mac_ptr
+= *offset_size
;
20464 /* Vendor opcode descriptions. */
20465 if ((flags
& 4) != 0)
20467 unsigned int i
, count
;
20469 count
= read_1_byte (abfd
, mac_ptr
);
20471 for (i
= 0; i
< count
; ++i
)
20473 unsigned int opcode
, bytes_read
;
20476 opcode
= read_1_byte (abfd
, mac_ptr
);
20478 opcode_definitions
[opcode
] = mac_ptr
;
20479 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20480 mac_ptr
+= bytes_read
;
20489 /* A helper for dwarf_decode_macros that handles the GNU extensions,
20490 including DW_MACRO_GNU_transparent_include. */
20493 dwarf_decode_macro_bytes (bfd
*abfd
,
20494 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
20495 struct macro_source_file
*current_file
,
20496 struct line_header
*lh
, const char *comp_dir
,
20497 struct dwarf2_section_info
*section
,
20498 int section_is_gnu
, int section_is_dwz
,
20499 unsigned int offset_size
,
20500 struct objfile
*objfile
,
20501 htab_t include_hash
)
20503 enum dwarf_macro_record_type macinfo_type
;
20504 int at_commandline
;
20505 const gdb_byte
*opcode_definitions
[256];
20507 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
20508 &offset_size
, section_is_gnu
);
20509 if (mac_ptr
== NULL
)
20511 /* We already issued a complaint. */
20515 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
20516 GDB is still reading the definitions from command line. First
20517 DW_MACINFO_start_file will need to be ignored as it was already executed
20518 to create CURRENT_FILE for the main source holding also the command line
20519 definitions. On first met DW_MACINFO_start_file this flag is reset to
20520 normally execute all the remaining DW_MACINFO_start_file macinfos. */
20522 at_commandline
= 1;
20526 /* Do we at least have room for a macinfo type byte? */
20527 if (mac_ptr
>= mac_end
)
20529 dwarf2_section_buffer_overflow_complaint (section
);
20533 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
20536 /* Note that we rely on the fact that the corresponding GNU and
20537 DWARF constants are the same. */
20538 switch (macinfo_type
)
20540 /* A zero macinfo type indicates the end of the macro
20545 case DW_MACRO_GNU_define
:
20546 case DW_MACRO_GNU_undef
:
20547 case DW_MACRO_GNU_define_indirect
:
20548 case DW_MACRO_GNU_undef_indirect
:
20549 case DW_MACRO_GNU_define_indirect_alt
:
20550 case DW_MACRO_GNU_undef_indirect_alt
:
20552 unsigned int bytes_read
;
20557 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20558 mac_ptr
+= bytes_read
;
20560 if (macinfo_type
== DW_MACRO_GNU_define
20561 || macinfo_type
== DW_MACRO_GNU_undef
)
20563 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
20564 mac_ptr
+= bytes_read
;
20568 LONGEST str_offset
;
20570 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
20571 mac_ptr
+= offset_size
;
20573 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
20574 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
20577 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
20579 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
20582 body
= read_indirect_string_at_offset (abfd
, str_offset
);
20585 is_define
= (macinfo_type
== DW_MACRO_GNU_define
20586 || macinfo_type
== DW_MACRO_GNU_define_indirect
20587 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
20588 if (! current_file
)
20590 /* DWARF violation as no main source is present. */
20591 complaint (&symfile_complaints
,
20592 _("debug info with no main source gives macro %s "
20594 is_define
? _("definition") : _("undefinition"),
20598 if ((line
== 0 && !at_commandline
)
20599 || (line
!= 0 && at_commandline
))
20600 complaint (&symfile_complaints
,
20601 _("debug info gives %s macro %s with %s line %d: %s"),
20602 at_commandline
? _("command-line") : _("in-file"),
20603 is_define
? _("definition") : _("undefinition"),
20604 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
20607 parse_macro_definition (current_file
, line
, body
);
20610 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
20611 || macinfo_type
== DW_MACRO_GNU_undef_indirect
20612 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
20613 macro_undef (current_file
, line
, body
);
20618 case DW_MACRO_GNU_start_file
:
20620 unsigned int bytes_read
;
20623 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20624 mac_ptr
+= bytes_read
;
20625 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20626 mac_ptr
+= bytes_read
;
20628 if ((line
== 0 && !at_commandline
)
20629 || (line
!= 0 && at_commandline
))
20630 complaint (&symfile_complaints
,
20631 _("debug info gives source %d included "
20632 "from %s at %s line %d"),
20633 file
, at_commandline
? _("command-line") : _("file"),
20634 line
== 0 ? _("zero") : _("non-zero"), line
);
20636 if (at_commandline
)
20638 /* This DW_MACRO_GNU_start_file was executed in the
20640 at_commandline
= 0;
20643 current_file
= macro_start_file (file
, line
,
20644 current_file
, comp_dir
,
20649 case DW_MACRO_GNU_end_file
:
20650 if (! current_file
)
20651 complaint (&symfile_complaints
,
20652 _("macro debug info has an unmatched "
20653 "`close_file' directive"));
20656 current_file
= current_file
->included_by
;
20657 if (! current_file
)
20659 enum dwarf_macro_record_type next_type
;
20661 /* GCC circa March 2002 doesn't produce the zero
20662 type byte marking the end of the compilation
20663 unit. Complain if it's not there, but exit no
20666 /* Do we at least have room for a macinfo type byte? */
20667 if (mac_ptr
>= mac_end
)
20669 dwarf2_section_buffer_overflow_complaint (section
);
20673 /* We don't increment mac_ptr here, so this is just
20675 next_type
= read_1_byte (abfd
, mac_ptr
);
20676 if (next_type
!= 0)
20677 complaint (&symfile_complaints
,
20678 _("no terminating 0-type entry for "
20679 "macros in `.debug_macinfo' section"));
20686 case DW_MACRO_GNU_transparent_include
:
20687 case DW_MACRO_GNU_transparent_include_alt
:
20691 bfd
*include_bfd
= abfd
;
20692 struct dwarf2_section_info
*include_section
= section
;
20693 struct dwarf2_section_info alt_section
;
20694 const gdb_byte
*include_mac_end
= mac_end
;
20695 int is_dwz
= section_is_dwz
;
20696 const gdb_byte
*new_mac_ptr
;
20698 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
20699 mac_ptr
+= offset_size
;
20701 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
20703 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
20705 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
20708 include_section
= &dwz
->macro
;
20709 include_bfd
= get_section_bfd_owner (include_section
);
20710 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
20714 new_mac_ptr
= include_section
->buffer
+ offset
;
20715 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
20719 /* This has actually happened; see
20720 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
20721 complaint (&symfile_complaints
,
20722 _("recursive DW_MACRO_GNU_transparent_include in "
20723 ".debug_macro section"));
20727 *slot
= (void *) new_mac_ptr
;
20729 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
20730 include_mac_end
, current_file
,
20732 section
, section_is_gnu
, is_dwz
,
20733 offset_size
, objfile
, include_hash
);
20735 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
20740 case DW_MACINFO_vendor_ext
:
20741 if (!section_is_gnu
)
20743 unsigned int bytes_read
;
20746 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20747 mac_ptr
+= bytes_read
;
20748 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
20749 mac_ptr
+= bytes_read
;
20751 /* We don't recognize any vendor extensions. */
20757 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
20758 mac_ptr
, mac_end
, abfd
, offset_size
,
20760 if (mac_ptr
== NULL
)
20764 } while (macinfo_type
!= 0);
20768 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
20769 const char *comp_dir
, int section_is_gnu
)
20771 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20772 struct line_header
*lh
= cu
->line_header
;
20774 const gdb_byte
*mac_ptr
, *mac_end
;
20775 struct macro_source_file
*current_file
= 0;
20776 enum dwarf_macro_record_type macinfo_type
;
20777 unsigned int offset_size
= cu
->header
.offset_size
;
20778 const gdb_byte
*opcode_definitions
[256];
20779 struct cleanup
*cleanup
;
20780 htab_t include_hash
;
20782 struct dwarf2_section_info
*section
;
20783 const char *section_name
;
20785 if (cu
->dwo_unit
!= NULL
)
20787 if (section_is_gnu
)
20789 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
20790 section_name
= ".debug_macro.dwo";
20794 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
20795 section_name
= ".debug_macinfo.dwo";
20800 if (section_is_gnu
)
20802 section
= &dwarf2_per_objfile
->macro
;
20803 section_name
= ".debug_macro";
20807 section
= &dwarf2_per_objfile
->macinfo
;
20808 section_name
= ".debug_macinfo";
20812 dwarf2_read_section (objfile
, section
);
20813 if (section
->buffer
== NULL
)
20815 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
20818 abfd
= get_section_bfd_owner (section
);
20820 /* First pass: Find the name of the base filename.
20821 This filename is needed in order to process all macros whose definition
20822 (or undefinition) comes from the command line. These macros are defined
20823 before the first DW_MACINFO_start_file entry, and yet still need to be
20824 associated to the base file.
20826 To determine the base file name, we scan the macro definitions until we
20827 reach the first DW_MACINFO_start_file entry. We then initialize
20828 CURRENT_FILE accordingly so that any macro definition found before the
20829 first DW_MACINFO_start_file can still be associated to the base file. */
20831 mac_ptr
= section
->buffer
+ offset
;
20832 mac_end
= section
->buffer
+ section
->size
;
20834 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
20835 &offset_size
, section_is_gnu
);
20836 if (mac_ptr
== NULL
)
20838 /* We already issued a complaint. */
20844 /* Do we at least have room for a macinfo type byte? */
20845 if (mac_ptr
>= mac_end
)
20847 /* Complaint is printed during the second pass as GDB will probably
20848 stop the first pass earlier upon finding
20849 DW_MACINFO_start_file. */
20853 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
20856 /* Note that we rely on the fact that the corresponding GNU and
20857 DWARF constants are the same. */
20858 switch (macinfo_type
)
20860 /* A zero macinfo type indicates the end of the macro
20865 case DW_MACRO_GNU_define
:
20866 case DW_MACRO_GNU_undef
:
20867 /* Only skip the data by MAC_PTR. */
20869 unsigned int bytes_read
;
20871 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20872 mac_ptr
+= bytes_read
;
20873 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
20874 mac_ptr
+= bytes_read
;
20878 case DW_MACRO_GNU_start_file
:
20880 unsigned int bytes_read
;
20883 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20884 mac_ptr
+= bytes_read
;
20885 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20886 mac_ptr
+= bytes_read
;
20888 current_file
= macro_start_file (file
, line
, current_file
,
20889 comp_dir
, lh
, objfile
);
20893 case DW_MACRO_GNU_end_file
:
20894 /* No data to skip by MAC_PTR. */
20897 case DW_MACRO_GNU_define_indirect
:
20898 case DW_MACRO_GNU_undef_indirect
:
20899 case DW_MACRO_GNU_define_indirect_alt
:
20900 case DW_MACRO_GNU_undef_indirect_alt
:
20902 unsigned int bytes_read
;
20904 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20905 mac_ptr
+= bytes_read
;
20906 mac_ptr
+= offset_size
;
20910 case DW_MACRO_GNU_transparent_include
:
20911 case DW_MACRO_GNU_transparent_include_alt
:
20912 /* Note that, according to the spec, a transparent include
20913 chain cannot call DW_MACRO_GNU_start_file. So, we can just
20914 skip this opcode. */
20915 mac_ptr
+= offset_size
;
20918 case DW_MACINFO_vendor_ext
:
20919 /* Only skip the data by MAC_PTR. */
20920 if (!section_is_gnu
)
20922 unsigned int bytes_read
;
20924 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
20925 mac_ptr
+= bytes_read
;
20926 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
20927 mac_ptr
+= bytes_read
;
20932 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
20933 mac_ptr
, mac_end
, abfd
, offset_size
,
20935 if (mac_ptr
== NULL
)
20939 } while (macinfo_type
!= 0 && current_file
== NULL
);
20941 /* Second pass: Process all entries.
20943 Use the AT_COMMAND_LINE flag to determine whether we are still processing
20944 command-line macro definitions/undefinitions. This flag is unset when we
20945 reach the first DW_MACINFO_start_file entry. */
20947 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
20948 NULL
, xcalloc
, xfree
);
20949 cleanup
= make_cleanup_htab_delete (include_hash
);
20950 mac_ptr
= section
->buffer
+ offset
;
20951 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
20952 *slot
= (void *) mac_ptr
;
20953 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
20954 current_file
, lh
, comp_dir
, section
,
20956 offset_size
, objfile
, include_hash
);
20957 do_cleanups (cleanup
);
20960 /* Check if the attribute's form is a DW_FORM_block*
20961 if so return true else false. */
20964 attr_form_is_block (const struct attribute
*attr
)
20966 return (attr
== NULL
? 0 :
20967 attr
->form
== DW_FORM_block1
20968 || attr
->form
== DW_FORM_block2
20969 || attr
->form
== DW_FORM_block4
20970 || attr
->form
== DW_FORM_block
20971 || attr
->form
== DW_FORM_exprloc
);
20974 /* Return non-zero if ATTR's value is a section offset --- classes
20975 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
20976 You may use DW_UNSND (attr) to retrieve such offsets.
20978 Section 7.5.4, "Attribute Encodings", explains that no attribute
20979 may have a value that belongs to more than one of these classes; it
20980 would be ambiguous if we did, because we use the same forms for all
20984 attr_form_is_section_offset (const struct attribute
*attr
)
20986 return (attr
->form
== DW_FORM_data4
20987 || attr
->form
== DW_FORM_data8
20988 || attr
->form
== DW_FORM_sec_offset
);
20991 /* Return non-zero if ATTR's value falls in the 'constant' class, or
20992 zero otherwise. When this function returns true, you can apply
20993 dwarf2_get_attr_constant_value to it.
20995 However, note that for some attributes you must check
20996 attr_form_is_section_offset before using this test. DW_FORM_data4
20997 and DW_FORM_data8 are members of both the constant class, and of
20998 the classes that contain offsets into other debug sections
20999 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21000 that, if an attribute's can be either a constant or one of the
21001 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21002 taken as section offsets, not constants. */
21005 attr_form_is_constant (const struct attribute
*attr
)
21007 switch (attr
->form
)
21009 case DW_FORM_sdata
:
21010 case DW_FORM_udata
:
21011 case DW_FORM_data1
:
21012 case DW_FORM_data2
:
21013 case DW_FORM_data4
:
21014 case DW_FORM_data8
:
21022 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21023 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21026 attr_form_is_ref (const struct attribute
*attr
)
21028 switch (attr
->form
)
21030 case DW_FORM_ref_addr
:
21035 case DW_FORM_ref_udata
:
21036 case DW_FORM_GNU_ref_alt
:
21043 /* Return the .debug_loc section to use for CU.
21044 For DWO files use .debug_loc.dwo. */
21046 static struct dwarf2_section_info
*
21047 cu_debug_loc_section (struct dwarf2_cu
*cu
)
21050 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
21051 return &dwarf2_per_objfile
->loc
;
21054 /* A helper function that fills in a dwarf2_loclist_baton. */
21057 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
21058 struct dwarf2_loclist_baton
*baton
,
21059 const struct attribute
*attr
)
21061 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21063 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
21065 baton
->per_cu
= cu
->per_cu
;
21066 gdb_assert (baton
->per_cu
);
21067 /* We don't know how long the location list is, but make sure we
21068 don't run off the edge of the section. */
21069 baton
->size
= section
->size
- DW_UNSND (attr
);
21070 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
21071 baton
->base_address
= cu
->base_address
;
21072 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
21076 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
21077 struct dwarf2_cu
*cu
, int is_block
)
21079 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21080 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21082 if (attr_form_is_section_offset (attr
)
21083 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21084 the section. If so, fall through to the complaint in the
21086 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
21088 struct dwarf2_loclist_baton
*baton
;
21090 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21091 sizeof (struct dwarf2_loclist_baton
));
21093 fill_in_loclist_baton (cu
, baton
, attr
);
21095 if (cu
->base_known
== 0)
21096 complaint (&symfile_complaints
,
21097 _("Location list used without "
21098 "specifying the CU base address."));
21100 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21101 ? dwarf2_loclist_block_index
21102 : dwarf2_loclist_index
);
21103 SYMBOL_LOCATION_BATON (sym
) = baton
;
21107 struct dwarf2_locexpr_baton
*baton
;
21109 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21110 sizeof (struct dwarf2_locexpr_baton
));
21111 baton
->per_cu
= cu
->per_cu
;
21112 gdb_assert (baton
->per_cu
);
21114 if (attr_form_is_block (attr
))
21116 /* Note that we're just copying the block's data pointer
21117 here, not the actual data. We're still pointing into the
21118 info_buffer for SYM's objfile; right now we never release
21119 that buffer, but when we do clean up properly this may
21121 baton
->size
= DW_BLOCK (attr
)->size
;
21122 baton
->data
= DW_BLOCK (attr
)->data
;
21126 dwarf2_invalid_attrib_class_complaint ("location description",
21127 SYMBOL_NATURAL_NAME (sym
));
21131 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21132 ? dwarf2_locexpr_block_index
21133 : dwarf2_locexpr_index
);
21134 SYMBOL_LOCATION_BATON (sym
) = baton
;
21138 /* Return the OBJFILE associated with the compilation unit CU. If CU
21139 came from a separate debuginfo file, then the master objfile is
21143 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
21145 struct objfile
*objfile
= per_cu
->objfile
;
21147 /* Return the master objfile, so that we can report and look up the
21148 correct file containing this variable. */
21149 if (objfile
->separate_debug_objfile_backlink
)
21150 objfile
= objfile
->separate_debug_objfile_backlink
;
21155 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21156 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21157 CU_HEADERP first. */
21159 static const struct comp_unit_head
*
21160 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
21161 struct dwarf2_per_cu_data
*per_cu
)
21163 const gdb_byte
*info_ptr
;
21166 return &per_cu
->cu
->header
;
21168 info_ptr
= per_cu
->section
->buffer
+ per_cu
->offset
.sect_off
;
21170 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
21171 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
21176 /* Return the address size given in the compilation unit header for CU. */
21179 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21181 struct comp_unit_head cu_header_local
;
21182 const struct comp_unit_head
*cu_headerp
;
21184 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21186 return cu_headerp
->addr_size
;
21189 /* Return the offset size given in the compilation unit header for CU. */
21192 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
21194 struct comp_unit_head cu_header_local
;
21195 const struct comp_unit_head
*cu_headerp
;
21197 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21199 return cu_headerp
->offset_size
;
21202 /* See its dwarf2loc.h declaration. */
21205 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21207 struct comp_unit_head cu_header_local
;
21208 const struct comp_unit_head
*cu_headerp
;
21210 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21212 if (cu_headerp
->version
== 2)
21213 return cu_headerp
->addr_size
;
21215 return cu_headerp
->offset_size
;
21218 /* Return the text offset of the CU. The returned offset comes from
21219 this CU's objfile. If this objfile came from a separate debuginfo
21220 file, then the offset may be different from the corresponding
21221 offset in the parent objfile. */
21224 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
21226 struct objfile
*objfile
= per_cu
->objfile
;
21228 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21231 /* Locate the .debug_info compilation unit from CU's objfile which contains
21232 the DIE at OFFSET. Raises an error on failure. */
21234 static struct dwarf2_per_cu_data
*
21235 dwarf2_find_containing_comp_unit (sect_offset offset
,
21236 unsigned int offset_in_dwz
,
21237 struct objfile
*objfile
)
21239 struct dwarf2_per_cu_data
*this_cu
;
21241 const sect_offset
*cu_off
;
21244 high
= dwarf2_per_objfile
->n_comp_units
- 1;
21247 struct dwarf2_per_cu_data
*mid_cu
;
21248 int mid
= low
+ (high
- low
) / 2;
21250 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
21251 cu_off
= &mid_cu
->offset
;
21252 if (mid_cu
->is_dwz
> offset_in_dwz
21253 || (mid_cu
->is_dwz
== offset_in_dwz
21254 && cu_off
->sect_off
>= offset
.sect_off
))
21259 gdb_assert (low
== high
);
21260 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
21261 cu_off
= &this_cu
->offset
;
21262 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
21264 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
21265 error (_("Dwarf Error: could not find partial DIE containing "
21266 "offset 0x%lx [in module %s]"),
21267 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
21269 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
21270 <= offset
.sect_off
);
21271 return dwarf2_per_objfile
->all_comp_units
[low
-1];
21275 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
21276 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
21277 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
21278 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
21279 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
21284 /* Initialize dwarf2_cu CU, owned by PER_CU. */
21287 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
21289 memset (cu
, 0, sizeof (*cu
));
21291 cu
->per_cu
= per_cu
;
21292 cu
->objfile
= per_cu
->objfile
;
21293 obstack_init (&cu
->comp_unit_obstack
);
21296 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
21299 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
21300 enum language pretend_language
)
21302 struct attribute
*attr
;
21304 /* Set the language we're debugging. */
21305 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
21307 set_cu_language (DW_UNSND (attr
), cu
);
21310 cu
->language
= pretend_language
;
21311 cu
->language_defn
= language_def (cu
->language
);
21314 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
21316 cu
->producer
= DW_STRING (attr
);
21319 /* Release one cached compilation unit, CU. We unlink it from the tree
21320 of compilation units, but we don't remove it from the read_in_chain;
21321 the caller is responsible for that.
21322 NOTE: DATA is a void * because this function is also used as a
21323 cleanup routine. */
21326 free_heap_comp_unit (void *data
)
21328 struct dwarf2_cu
*cu
= data
;
21330 gdb_assert (cu
->per_cu
!= NULL
);
21331 cu
->per_cu
->cu
= NULL
;
21334 obstack_free (&cu
->comp_unit_obstack
, NULL
);
21339 /* This cleanup function is passed the address of a dwarf2_cu on the stack
21340 when we're finished with it. We can't free the pointer itself, but be
21341 sure to unlink it from the cache. Also release any associated storage. */
21344 free_stack_comp_unit (void *data
)
21346 struct dwarf2_cu
*cu
= data
;
21348 gdb_assert (cu
->per_cu
!= NULL
);
21349 cu
->per_cu
->cu
= NULL
;
21352 obstack_free (&cu
->comp_unit_obstack
, NULL
);
21353 cu
->partial_dies
= NULL
;
21356 /* Free all cached compilation units. */
21359 free_cached_comp_units (void *data
)
21361 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
21363 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21364 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
21365 while (per_cu
!= NULL
)
21367 struct dwarf2_per_cu_data
*next_cu
;
21369 next_cu
= per_cu
->cu
->read_in_chain
;
21371 free_heap_comp_unit (per_cu
->cu
);
21372 *last_chain
= next_cu
;
21378 /* Increase the age counter on each cached compilation unit, and free
21379 any that are too old. */
21382 age_cached_comp_units (void)
21384 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
21386 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
21387 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21388 while (per_cu
!= NULL
)
21390 per_cu
->cu
->last_used
++;
21391 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
21392 dwarf2_mark (per_cu
->cu
);
21393 per_cu
= per_cu
->cu
->read_in_chain
;
21396 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21397 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
21398 while (per_cu
!= NULL
)
21400 struct dwarf2_per_cu_data
*next_cu
;
21402 next_cu
= per_cu
->cu
->read_in_chain
;
21404 if (!per_cu
->cu
->mark
)
21406 free_heap_comp_unit (per_cu
->cu
);
21407 *last_chain
= next_cu
;
21410 last_chain
= &per_cu
->cu
->read_in_chain
;
21416 /* Remove a single compilation unit from the cache. */
21419 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
21421 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
21423 per_cu
= dwarf2_per_objfile
->read_in_chain
;
21424 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
21425 while (per_cu
!= NULL
)
21427 struct dwarf2_per_cu_data
*next_cu
;
21429 next_cu
= per_cu
->cu
->read_in_chain
;
21431 if (per_cu
== target_per_cu
)
21433 free_heap_comp_unit (per_cu
->cu
);
21435 *last_chain
= next_cu
;
21439 last_chain
= &per_cu
->cu
->read_in_chain
;
21445 /* Release all extra memory associated with OBJFILE. */
21448 dwarf2_free_objfile (struct objfile
*objfile
)
21450 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
21452 if (dwarf2_per_objfile
== NULL
)
21455 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
21456 free_cached_comp_units (NULL
);
21458 if (dwarf2_per_objfile
->quick_file_names_table
)
21459 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
21461 /* Everything else should be on the objfile obstack. */
21464 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
21465 We store these in a hash table separate from the DIEs, and preserve them
21466 when the DIEs are flushed out of cache.
21468 The CU "per_cu" pointer is needed because offset alone is not enough to
21469 uniquely identify the type. A file may have multiple .debug_types sections,
21470 or the type may come from a DWO file. Furthermore, while it's more logical
21471 to use per_cu->section+offset, with Fission the section with the data is in
21472 the DWO file but we don't know that section at the point we need it.
21473 We have to use something in dwarf2_per_cu_data (or the pointer to it)
21474 because we can enter the lookup routine, get_die_type_at_offset, from
21475 outside this file, and thus won't necessarily have PER_CU->cu.
21476 Fortunately, PER_CU is stable for the life of the objfile. */
21478 struct dwarf2_per_cu_offset_and_type
21480 const struct dwarf2_per_cu_data
*per_cu
;
21481 sect_offset offset
;
21485 /* Hash function for a dwarf2_per_cu_offset_and_type. */
21488 per_cu_offset_and_type_hash (const void *item
)
21490 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
21492 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
21495 /* Equality function for a dwarf2_per_cu_offset_and_type. */
21498 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
21500 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
21501 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
21503 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
21504 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
21507 /* Set the type associated with DIE to TYPE. Save it in CU's hash
21508 table if necessary. For convenience, return TYPE.
21510 The DIEs reading must have careful ordering to:
21511 * Not cause infite loops trying to read in DIEs as a prerequisite for
21512 reading current DIE.
21513 * Not trying to dereference contents of still incompletely read in types
21514 while reading in other DIEs.
21515 * Enable referencing still incompletely read in types just by a pointer to
21516 the type without accessing its fields.
21518 Therefore caller should follow these rules:
21519 * Try to fetch any prerequisite types we may need to build this DIE type
21520 before building the type and calling set_die_type.
21521 * After building type call set_die_type for current DIE as soon as
21522 possible before fetching more types to complete the current type.
21523 * Make the type as complete as possible before fetching more types. */
21525 static struct type
*
21526 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
21528 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
21529 struct objfile
*objfile
= cu
->objfile
;
21531 /* For Ada types, make sure that the gnat-specific data is always
21532 initialized (if not already set). There are a few types where
21533 we should not be doing so, because the type-specific area is
21534 already used to hold some other piece of info (eg: TYPE_CODE_FLT
21535 where the type-specific area is used to store the floatformat).
21536 But this is not a problem, because the gnat-specific information
21537 is actually not needed for these types. */
21538 if (need_gnat_info (cu
)
21539 && TYPE_CODE (type
) != TYPE_CODE_FUNC
21540 && TYPE_CODE (type
) != TYPE_CODE_FLT
21541 && !HAVE_GNAT_AUX_INFO (type
))
21542 INIT_GNAT_SPECIFIC (type
);
21544 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
21546 dwarf2_per_objfile
->die_type_hash
=
21547 htab_create_alloc_ex (127,
21548 per_cu_offset_and_type_hash
,
21549 per_cu_offset_and_type_eq
,
21551 &objfile
->objfile_obstack
,
21552 hashtab_obstack_allocate
,
21553 dummy_obstack_deallocate
);
21556 ofs
.per_cu
= cu
->per_cu
;
21557 ofs
.offset
= die
->offset
;
21559 slot
= (struct dwarf2_per_cu_offset_and_type
**)
21560 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
21562 complaint (&symfile_complaints
,
21563 _("A problem internal to GDB: DIE 0x%x has type already set"),
21564 die
->offset
.sect_off
);
21565 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
21570 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
21571 or return NULL if the die does not have a saved type. */
21573 static struct type
*
21574 get_die_type_at_offset (sect_offset offset
,
21575 struct dwarf2_per_cu_data
*per_cu
)
21577 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
21579 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
21582 ofs
.per_cu
= per_cu
;
21583 ofs
.offset
= offset
;
21584 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
21591 /* Look up the type for DIE in CU in die_type_hash,
21592 or return NULL if DIE does not have a saved type. */
21594 static struct type
*
21595 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21597 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
21600 /* Add a dependence relationship from CU to REF_PER_CU. */
21603 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
21604 struct dwarf2_per_cu_data
*ref_per_cu
)
21608 if (cu
->dependencies
== NULL
)
21610 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
21611 NULL
, &cu
->comp_unit_obstack
,
21612 hashtab_obstack_allocate
,
21613 dummy_obstack_deallocate
);
21615 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
21617 *slot
= ref_per_cu
;
21620 /* Subroutine of dwarf2_mark to pass to htab_traverse.
21621 Set the mark field in every compilation unit in the
21622 cache that we must keep because we are keeping CU. */
21625 dwarf2_mark_helper (void **slot
, void *data
)
21627 struct dwarf2_per_cu_data
*per_cu
;
21629 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
21631 /* cu->dependencies references may not yet have been ever read if QUIT aborts
21632 reading of the chain. As such dependencies remain valid it is not much
21633 useful to track and undo them during QUIT cleanups. */
21634 if (per_cu
->cu
== NULL
)
21637 if (per_cu
->cu
->mark
)
21639 per_cu
->cu
->mark
= 1;
21641 if (per_cu
->cu
->dependencies
!= NULL
)
21642 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
21647 /* Set the mark field in CU and in every other compilation unit in the
21648 cache that we must keep because we are keeping CU. */
21651 dwarf2_mark (struct dwarf2_cu
*cu
)
21656 if (cu
->dependencies
!= NULL
)
21657 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
21661 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
21665 per_cu
->cu
->mark
= 0;
21666 per_cu
= per_cu
->cu
->read_in_chain
;
21670 /* Trivial hash function for partial_die_info: the hash value of a DIE
21671 is its offset in .debug_info for this objfile. */
21674 partial_die_hash (const void *item
)
21676 const struct partial_die_info
*part_die
= item
;
21678 return part_die
->offset
.sect_off
;
21681 /* Trivial comparison function for partial_die_info structures: two DIEs
21682 are equal if they have the same offset. */
21685 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
21687 const struct partial_die_info
*part_die_lhs
= item_lhs
;
21688 const struct partial_die_info
*part_die_rhs
= item_rhs
;
21690 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
21693 static struct cmd_list_element
*set_dwarf2_cmdlist
;
21694 static struct cmd_list_element
*show_dwarf2_cmdlist
;
21697 set_dwarf2_cmd (char *args
, int from_tty
)
21699 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
21703 show_dwarf2_cmd (char *args
, int from_tty
)
21705 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
21708 /* Free data associated with OBJFILE, if necessary. */
21711 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
21713 struct dwarf2_per_objfile
*data
= d
;
21716 /* Make sure we don't accidentally use dwarf2_per_objfile while
21718 dwarf2_per_objfile
= NULL
;
21720 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
21721 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
21723 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
21724 VEC_free (dwarf2_per_cu_ptr
,
21725 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
21726 xfree (data
->all_type_units
);
21728 VEC_free (dwarf2_section_info_def
, data
->types
);
21730 if (data
->dwo_files
)
21731 free_dwo_files (data
->dwo_files
, objfile
);
21732 if (data
->dwp_file
)
21733 gdb_bfd_unref (data
->dwp_file
->dbfd
);
21735 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
21736 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
21740 /* The "save gdb-index" command. */
21742 /* The contents of the hash table we create when building the string
21744 struct strtab_entry
21746 offset_type offset
;
21750 /* Hash function for a strtab_entry.
21752 Function is used only during write_hash_table so no index format backward
21753 compatibility is needed. */
21756 hash_strtab_entry (const void *e
)
21758 const struct strtab_entry
*entry
= e
;
21759 return mapped_index_string_hash (INT_MAX
, entry
->str
);
21762 /* Equality function for a strtab_entry. */
21765 eq_strtab_entry (const void *a
, const void *b
)
21767 const struct strtab_entry
*ea
= a
;
21768 const struct strtab_entry
*eb
= b
;
21769 return !strcmp (ea
->str
, eb
->str
);
21772 /* Create a strtab_entry hash table. */
21775 create_strtab (void)
21777 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
21778 xfree
, xcalloc
, xfree
);
21781 /* Add a string to the constant pool. Return the string's offset in
21785 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
21788 struct strtab_entry entry
;
21789 struct strtab_entry
*result
;
21792 slot
= htab_find_slot (table
, &entry
, INSERT
);
21797 result
= XNEW (struct strtab_entry
);
21798 result
->offset
= obstack_object_size (cpool
);
21800 obstack_grow_str0 (cpool
, str
);
21803 return result
->offset
;
21806 /* An entry in the symbol table. */
21807 struct symtab_index_entry
21809 /* The name of the symbol. */
21811 /* The offset of the name in the constant pool. */
21812 offset_type index_offset
;
21813 /* A sorted vector of the indices of all the CUs that hold an object
21815 VEC (offset_type
) *cu_indices
;
21818 /* The symbol table. This is a power-of-2-sized hash table. */
21819 struct mapped_symtab
21821 offset_type n_elements
;
21823 struct symtab_index_entry
**data
;
21826 /* Hash function for a symtab_index_entry. */
21829 hash_symtab_entry (const void *e
)
21831 const struct symtab_index_entry
*entry
= e
;
21832 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
21833 sizeof (offset_type
) * VEC_length (offset_type
,
21834 entry
->cu_indices
),
21838 /* Equality function for a symtab_index_entry. */
21841 eq_symtab_entry (const void *a
, const void *b
)
21843 const struct symtab_index_entry
*ea
= a
;
21844 const struct symtab_index_entry
*eb
= b
;
21845 int len
= VEC_length (offset_type
, ea
->cu_indices
);
21846 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
21848 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
21849 VEC_address (offset_type
, eb
->cu_indices
),
21850 sizeof (offset_type
) * len
);
21853 /* Destroy a symtab_index_entry. */
21856 delete_symtab_entry (void *p
)
21858 struct symtab_index_entry
*entry
= p
;
21859 VEC_free (offset_type
, entry
->cu_indices
);
21863 /* Create a hash table holding symtab_index_entry objects. */
21866 create_symbol_hash_table (void)
21868 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
21869 delete_symtab_entry
, xcalloc
, xfree
);
21872 /* Create a new mapped symtab object. */
21874 static struct mapped_symtab
*
21875 create_mapped_symtab (void)
21877 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
21878 symtab
->n_elements
= 0;
21879 symtab
->size
= 1024;
21880 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
21884 /* Destroy a mapped_symtab. */
21887 cleanup_mapped_symtab (void *p
)
21889 struct mapped_symtab
*symtab
= p
;
21890 /* The contents of the array are freed when the other hash table is
21892 xfree (symtab
->data
);
21896 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
21899 Function is used only during write_hash_table so no index format backward
21900 compatibility is needed. */
21902 static struct symtab_index_entry
**
21903 find_slot (struct mapped_symtab
*symtab
, const char *name
)
21905 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
21907 index
= hash
& (symtab
->size
- 1);
21908 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
21912 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
21913 return &symtab
->data
[index
];
21914 index
= (index
+ step
) & (symtab
->size
- 1);
21918 /* Expand SYMTAB's hash table. */
21921 hash_expand (struct mapped_symtab
*symtab
)
21923 offset_type old_size
= symtab
->size
;
21925 struct symtab_index_entry
**old_entries
= symtab
->data
;
21928 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
21930 for (i
= 0; i
< old_size
; ++i
)
21932 if (old_entries
[i
])
21934 struct symtab_index_entry
**slot
= find_slot (symtab
,
21935 old_entries
[i
]->name
);
21936 *slot
= old_entries
[i
];
21940 xfree (old_entries
);
21943 /* Add an entry to SYMTAB. NAME is the name of the symbol.
21944 CU_INDEX is the index of the CU in which the symbol appears.
21945 IS_STATIC is one if the symbol is static, otherwise zero (global). */
21948 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
21949 int is_static
, gdb_index_symbol_kind kind
,
21950 offset_type cu_index
)
21952 struct symtab_index_entry
**slot
;
21953 offset_type cu_index_and_attrs
;
21955 ++symtab
->n_elements
;
21956 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
21957 hash_expand (symtab
);
21959 slot
= find_slot (symtab
, name
);
21962 *slot
= XNEW (struct symtab_index_entry
);
21963 (*slot
)->name
= name
;
21964 /* index_offset is set later. */
21965 (*slot
)->cu_indices
= NULL
;
21968 cu_index_and_attrs
= 0;
21969 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
21970 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
21971 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
21973 /* We don't want to record an index value twice as we want to avoid the
21975 We process all global symbols and then all static symbols
21976 (which would allow us to avoid the duplication by only having to check
21977 the last entry pushed), but a symbol could have multiple kinds in one CU.
21978 To keep things simple we don't worry about the duplication here and
21979 sort and uniqufy the list after we've processed all symbols. */
21980 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
21983 /* qsort helper routine for uniquify_cu_indices. */
21986 offset_type_compare (const void *ap
, const void *bp
)
21988 offset_type a
= *(offset_type
*) ap
;
21989 offset_type b
= *(offset_type
*) bp
;
21991 return (a
> b
) - (b
> a
);
21994 /* Sort and remove duplicates of all symbols' cu_indices lists. */
21997 uniquify_cu_indices (struct mapped_symtab
*symtab
)
22001 for (i
= 0; i
< symtab
->size
; ++i
)
22003 struct symtab_index_entry
*entry
= symtab
->data
[i
];
22006 && entry
->cu_indices
!= NULL
)
22008 unsigned int next_to_insert
, next_to_check
;
22009 offset_type last_value
;
22011 qsort (VEC_address (offset_type
, entry
->cu_indices
),
22012 VEC_length (offset_type
, entry
->cu_indices
),
22013 sizeof (offset_type
), offset_type_compare
);
22015 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
22016 next_to_insert
= 1;
22017 for (next_to_check
= 1;
22018 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
22021 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
22024 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
22026 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
22031 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
22036 /* Add a vector of indices to the constant pool. */
22039 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
22040 struct symtab_index_entry
*entry
)
22044 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
22047 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
22048 offset_type val
= MAYBE_SWAP (len
);
22053 entry
->index_offset
= obstack_object_size (cpool
);
22055 obstack_grow (cpool
, &val
, sizeof (val
));
22057 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
22060 val
= MAYBE_SWAP (iter
);
22061 obstack_grow (cpool
, &val
, sizeof (val
));
22066 struct symtab_index_entry
*old_entry
= *slot
;
22067 entry
->index_offset
= old_entry
->index_offset
;
22070 return entry
->index_offset
;
22073 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22074 constant pool entries going into the obstack CPOOL. */
22077 write_hash_table (struct mapped_symtab
*symtab
,
22078 struct obstack
*output
, struct obstack
*cpool
)
22081 htab_t symbol_hash_table
;
22084 symbol_hash_table
= create_symbol_hash_table ();
22085 str_table
= create_strtab ();
22087 /* We add all the index vectors to the constant pool first, to
22088 ensure alignment is ok. */
22089 for (i
= 0; i
< symtab
->size
; ++i
)
22091 if (symtab
->data
[i
])
22092 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
22095 /* Now write out the hash table. */
22096 for (i
= 0; i
< symtab
->size
; ++i
)
22098 offset_type str_off
, vec_off
;
22100 if (symtab
->data
[i
])
22102 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
22103 vec_off
= symtab
->data
[i
]->index_offset
;
22107 /* While 0 is a valid constant pool index, it is not valid
22108 to have 0 for both offsets. */
22113 str_off
= MAYBE_SWAP (str_off
);
22114 vec_off
= MAYBE_SWAP (vec_off
);
22116 obstack_grow (output
, &str_off
, sizeof (str_off
));
22117 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
22120 htab_delete (str_table
);
22121 htab_delete (symbol_hash_table
);
22124 /* Struct to map psymtab to CU index in the index file. */
22125 struct psymtab_cu_index_map
22127 struct partial_symtab
*psymtab
;
22128 unsigned int cu_index
;
22132 hash_psymtab_cu_index (const void *item
)
22134 const struct psymtab_cu_index_map
*map
= item
;
22136 return htab_hash_pointer (map
->psymtab
);
22140 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
22142 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
22143 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
22145 return lhs
->psymtab
== rhs
->psymtab
;
22148 /* Helper struct for building the address table. */
22149 struct addrmap_index_data
22151 struct objfile
*objfile
;
22152 struct obstack
*addr_obstack
;
22153 htab_t cu_index_htab
;
22155 /* Non-zero if the previous_* fields are valid.
22156 We can't write an entry until we see the next entry (since it is only then
22157 that we know the end of the entry). */
22158 int previous_valid
;
22159 /* Index of the CU in the table of all CUs in the index file. */
22160 unsigned int previous_cu_index
;
22161 /* Start address of the CU. */
22162 CORE_ADDR previous_cu_start
;
22165 /* Write an address entry to OBSTACK. */
22168 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
22169 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
22171 offset_type cu_index_to_write
;
22173 CORE_ADDR baseaddr
;
22175 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
22177 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
22178 obstack_grow (obstack
, addr
, 8);
22179 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
22180 obstack_grow (obstack
, addr
, 8);
22181 cu_index_to_write
= MAYBE_SWAP (cu_index
);
22182 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
22185 /* Worker function for traversing an addrmap to build the address table. */
22188 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
22190 struct addrmap_index_data
*data
= datap
;
22191 struct partial_symtab
*pst
= obj
;
22193 if (data
->previous_valid
)
22194 add_address_entry (data
->objfile
, data
->addr_obstack
,
22195 data
->previous_cu_start
, start_addr
,
22196 data
->previous_cu_index
);
22198 data
->previous_cu_start
= start_addr
;
22201 struct psymtab_cu_index_map find_map
, *map
;
22202 find_map
.psymtab
= pst
;
22203 map
= htab_find (data
->cu_index_htab
, &find_map
);
22204 gdb_assert (map
!= NULL
);
22205 data
->previous_cu_index
= map
->cu_index
;
22206 data
->previous_valid
= 1;
22209 data
->previous_valid
= 0;
22214 /* Write OBJFILE's address map to OBSTACK.
22215 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22216 in the index file. */
22219 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
22220 htab_t cu_index_htab
)
22222 struct addrmap_index_data addrmap_index_data
;
22224 /* When writing the address table, we have to cope with the fact that
22225 the addrmap iterator only provides the start of a region; we have to
22226 wait until the next invocation to get the start of the next region. */
22228 addrmap_index_data
.objfile
= objfile
;
22229 addrmap_index_data
.addr_obstack
= obstack
;
22230 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
22231 addrmap_index_data
.previous_valid
= 0;
22233 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
22234 &addrmap_index_data
);
22236 /* It's highly unlikely the last entry (end address = 0xff...ff)
22237 is valid, but we should still handle it.
22238 The end address is recorded as the start of the next region, but that
22239 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22241 if (addrmap_index_data
.previous_valid
)
22242 add_address_entry (objfile
, obstack
,
22243 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
22244 addrmap_index_data
.previous_cu_index
);
22247 /* Return the symbol kind of PSYM. */
22249 static gdb_index_symbol_kind
22250 symbol_kind (struct partial_symbol
*psym
)
22252 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
22253 enum address_class aclass
= PSYMBOL_CLASS (psym
);
22261 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
22263 return GDB_INDEX_SYMBOL_KIND_TYPE
;
22265 case LOC_CONST_BYTES
:
22266 case LOC_OPTIMIZED_OUT
:
22268 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
22270 /* Note: It's currently impossible to recognize psyms as enum values
22271 short of reading the type info. For now punt. */
22272 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
22274 /* There are other LOC_FOO values that one might want to classify
22275 as variables, but dwarf2read.c doesn't currently use them. */
22276 return GDB_INDEX_SYMBOL_KIND_OTHER
;
22278 case STRUCT_DOMAIN
:
22279 return GDB_INDEX_SYMBOL_KIND_TYPE
;
22281 return GDB_INDEX_SYMBOL_KIND_OTHER
;
22285 /* Add a list of partial symbols to SYMTAB. */
22288 write_psymbols (struct mapped_symtab
*symtab
,
22290 struct partial_symbol
**psymp
,
22292 offset_type cu_index
,
22295 for (; count
-- > 0; ++psymp
)
22297 struct partial_symbol
*psym
= *psymp
;
22300 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
22301 error (_("Ada is not currently supported by the index"));
22303 /* Only add a given psymbol once. */
22304 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
22307 gdb_index_symbol_kind kind
= symbol_kind (psym
);
22310 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
22311 is_static
, kind
, cu_index
);
22316 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
22317 exception if there is an error. */
22320 write_obstack (FILE *file
, struct obstack
*obstack
)
22322 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
22324 != obstack_object_size (obstack
))
22325 error (_("couldn't data write to file"));
22328 /* Unlink a file if the argument is not NULL. */
22331 unlink_if_set (void *p
)
22333 char **filename
= p
;
22335 unlink (*filename
);
22338 /* A helper struct used when iterating over debug_types. */
22339 struct signatured_type_index_data
22341 struct objfile
*objfile
;
22342 struct mapped_symtab
*symtab
;
22343 struct obstack
*types_list
;
22348 /* A helper function that writes a single signatured_type to an
22352 write_one_signatured_type (void **slot
, void *d
)
22354 struct signatured_type_index_data
*info
= d
;
22355 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
22356 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
22359 write_psymbols (info
->symtab
,
22361 info
->objfile
->global_psymbols
.list
22362 + psymtab
->globals_offset
,
22363 psymtab
->n_global_syms
, info
->cu_index
,
22365 write_psymbols (info
->symtab
,
22367 info
->objfile
->static_psymbols
.list
22368 + psymtab
->statics_offset
,
22369 psymtab
->n_static_syms
, info
->cu_index
,
22372 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
22373 entry
->per_cu
.offset
.sect_off
);
22374 obstack_grow (info
->types_list
, val
, 8);
22375 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
22376 entry
->type_offset_in_tu
.cu_off
);
22377 obstack_grow (info
->types_list
, val
, 8);
22378 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
22379 obstack_grow (info
->types_list
, val
, 8);
22386 /* Recurse into all "included" dependencies and write their symbols as
22387 if they appeared in this psymtab. */
22390 recursively_write_psymbols (struct objfile
*objfile
,
22391 struct partial_symtab
*psymtab
,
22392 struct mapped_symtab
*symtab
,
22394 offset_type cu_index
)
22398 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
22399 if (psymtab
->dependencies
[i
]->user
!= NULL
)
22400 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
22401 symtab
, psyms_seen
, cu_index
);
22403 write_psymbols (symtab
,
22405 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
22406 psymtab
->n_global_syms
, cu_index
,
22408 write_psymbols (symtab
,
22410 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
22411 psymtab
->n_static_syms
, cu_index
,
22415 /* Create an index file for OBJFILE in the directory DIR. */
22418 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
22420 struct cleanup
*cleanup
;
22421 char *filename
, *cleanup_filename
;
22422 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
22423 struct obstack cu_list
, types_cu_list
;
22426 struct mapped_symtab
*symtab
;
22427 offset_type val
, size_of_contents
, total_len
;
22430 htab_t cu_index_htab
;
22431 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
22433 if (dwarf2_per_objfile
->using_index
)
22434 error (_("Cannot use an index to create the index"));
22436 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
22437 error (_("Cannot make an index when the file has multiple .debug_types sections"));
22439 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
22442 if (stat (objfile_name (objfile
), &st
) < 0)
22443 perror_with_name (objfile_name (objfile
));
22445 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile_name (objfile
)),
22446 INDEX_SUFFIX
, (char *) NULL
);
22447 cleanup
= make_cleanup (xfree
, filename
);
22449 out_file
= gdb_fopen_cloexec (filename
, "wb");
22451 error (_("Can't open `%s' for writing"), filename
);
22453 cleanup_filename
= filename
;
22454 make_cleanup (unlink_if_set
, &cleanup_filename
);
22456 symtab
= create_mapped_symtab ();
22457 make_cleanup (cleanup_mapped_symtab
, symtab
);
22459 obstack_init (&addr_obstack
);
22460 make_cleanup_obstack_free (&addr_obstack
);
22462 obstack_init (&cu_list
);
22463 make_cleanup_obstack_free (&cu_list
);
22465 obstack_init (&types_cu_list
);
22466 make_cleanup_obstack_free (&types_cu_list
);
22468 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
22469 NULL
, xcalloc
, xfree
);
22470 make_cleanup_htab_delete (psyms_seen
);
22472 /* While we're scanning CU's create a table that maps a psymtab pointer
22473 (which is what addrmap records) to its index (which is what is recorded
22474 in the index file). This will later be needed to write the address
22476 cu_index_htab
= htab_create_alloc (100,
22477 hash_psymtab_cu_index
,
22478 eq_psymtab_cu_index
,
22479 NULL
, xcalloc
, xfree
);
22480 make_cleanup_htab_delete (cu_index_htab
);
22481 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
22482 xmalloc (sizeof (struct psymtab_cu_index_map
)
22483 * dwarf2_per_objfile
->n_comp_units
);
22484 make_cleanup (xfree
, psymtab_cu_index_map
);
22486 /* The CU list is already sorted, so we don't need to do additional
22487 work here. Also, the debug_types entries do not appear in
22488 all_comp_units, but only in their own hash table. */
22489 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
22491 struct dwarf2_per_cu_data
*per_cu
22492 = dwarf2_per_objfile
->all_comp_units
[i
];
22493 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
22495 struct psymtab_cu_index_map
*map
;
22498 /* CU of a shared file from 'dwz -m' may be unused by this main file.
22499 It may be referenced from a local scope but in such case it does not
22500 need to be present in .gdb_index. */
22501 if (psymtab
== NULL
)
22504 if (psymtab
->user
== NULL
)
22505 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
22507 map
= &psymtab_cu_index_map
[i
];
22508 map
->psymtab
= psymtab
;
22510 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
22511 gdb_assert (slot
!= NULL
);
22512 gdb_assert (*slot
== NULL
);
22515 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
22516 per_cu
->offset
.sect_off
);
22517 obstack_grow (&cu_list
, val
, 8);
22518 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
22519 obstack_grow (&cu_list
, val
, 8);
22522 /* Dump the address map. */
22523 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
22525 /* Write out the .debug_type entries, if any. */
22526 if (dwarf2_per_objfile
->signatured_types
)
22528 struct signatured_type_index_data sig_data
;
22530 sig_data
.objfile
= objfile
;
22531 sig_data
.symtab
= symtab
;
22532 sig_data
.types_list
= &types_cu_list
;
22533 sig_data
.psyms_seen
= psyms_seen
;
22534 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
22535 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
22536 write_one_signatured_type
, &sig_data
);
22539 /* Now that we've processed all symbols we can shrink their cu_indices
22541 uniquify_cu_indices (symtab
);
22543 obstack_init (&constant_pool
);
22544 make_cleanup_obstack_free (&constant_pool
);
22545 obstack_init (&symtab_obstack
);
22546 make_cleanup_obstack_free (&symtab_obstack
);
22547 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
22549 obstack_init (&contents
);
22550 make_cleanup_obstack_free (&contents
);
22551 size_of_contents
= 6 * sizeof (offset_type
);
22552 total_len
= size_of_contents
;
22554 /* The version number. */
22555 val
= MAYBE_SWAP (8);
22556 obstack_grow (&contents
, &val
, sizeof (val
));
22558 /* The offset of the CU list from the start of the file. */
22559 val
= MAYBE_SWAP (total_len
);
22560 obstack_grow (&contents
, &val
, sizeof (val
));
22561 total_len
+= obstack_object_size (&cu_list
);
22563 /* The offset of the types CU list from the start of the file. */
22564 val
= MAYBE_SWAP (total_len
);
22565 obstack_grow (&contents
, &val
, sizeof (val
));
22566 total_len
+= obstack_object_size (&types_cu_list
);
22568 /* The offset of the address table from the start of the file. */
22569 val
= MAYBE_SWAP (total_len
);
22570 obstack_grow (&contents
, &val
, sizeof (val
));
22571 total_len
+= obstack_object_size (&addr_obstack
);
22573 /* The offset of the symbol table from the start of the file. */
22574 val
= MAYBE_SWAP (total_len
);
22575 obstack_grow (&contents
, &val
, sizeof (val
));
22576 total_len
+= obstack_object_size (&symtab_obstack
);
22578 /* The offset of the constant pool from the start of the file. */
22579 val
= MAYBE_SWAP (total_len
);
22580 obstack_grow (&contents
, &val
, sizeof (val
));
22581 total_len
+= obstack_object_size (&constant_pool
);
22583 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
22585 write_obstack (out_file
, &contents
);
22586 write_obstack (out_file
, &cu_list
);
22587 write_obstack (out_file
, &types_cu_list
);
22588 write_obstack (out_file
, &addr_obstack
);
22589 write_obstack (out_file
, &symtab_obstack
);
22590 write_obstack (out_file
, &constant_pool
);
22594 /* We want to keep the file, so we set cleanup_filename to NULL
22595 here. See unlink_if_set. */
22596 cleanup_filename
= NULL
;
22598 do_cleanups (cleanup
);
22601 /* Implementation of the `save gdb-index' command.
22603 Note that the file format used by this command is documented in the
22604 GDB manual. Any changes here must be documented there. */
22607 save_gdb_index_command (char *arg
, int from_tty
)
22609 struct objfile
*objfile
;
22612 error (_("usage: save gdb-index DIRECTORY"));
22614 ALL_OBJFILES (objfile
)
22618 /* If the objfile does not correspond to an actual file, skip it. */
22619 if (stat (objfile_name (objfile
), &st
) < 0)
22622 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
22623 if (dwarf2_per_objfile
)
22625 volatile struct gdb_exception except
;
22627 TRY_CATCH (except
, RETURN_MASK_ERROR
)
22629 write_psymtabs_to_index (objfile
, arg
);
22631 if (except
.reason
< 0)
22632 exception_fprintf (gdb_stderr
, except
,
22633 _("Error while writing index for `%s': "),
22634 objfile_name (objfile
));
22641 int dwarf2_always_disassemble
;
22644 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
22645 struct cmd_list_element
*c
, const char *value
)
22647 fprintf_filtered (file
,
22648 _("Whether to always disassemble "
22649 "DWARF expressions is %s.\n"),
22654 show_check_physname (struct ui_file
*file
, int from_tty
,
22655 struct cmd_list_element
*c
, const char *value
)
22657 fprintf_filtered (file
,
22658 _("Whether to check \"physname\" is %s.\n"),
22662 void _initialize_dwarf2_read (void);
22665 _initialize_dwarf2_read (void)
22667 struct cmd_list_element
*c
;
22669 dwarf2_objfile_data_key
22670 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
22672 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
22673 Set DWARF 2 specific variables.\n\
22674 Configure DWARF 2 variables such as the cache size"),
22675 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
22676 0/*allow-unknown*/, &maintenance_set_cmdlist
);
22678 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
22679 Show DWARF 2 specific variables\n\
22680 Show DWARF 2 variables such as the cache size"),
22681 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
22682 0/*allow-unknown*/, &maintenance_show_cmdlist
);
22684 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
22685 &dwarf2_max_cache_age
, _("\
22686 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
22687 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
22688 A higher limit means that cached compilation units will be stored\n\
22689 in memory longer, and more total memory will be used. Zero disables\n\
22690 caching, which can slow down startup."),
22692 show_dwarf2_max_cache_age
,
22693 &set_dwarf2_cmdlist
,
22694 &show_dwarf2_cmdlist
);
22696 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
22697 &dwarf2_always_disassemble
, _("\
22698 Set whether `info address' always disassembles DWARF expressions."), _("\
22699 Show whether `info address' always disassembles DWARF expressions."), _("\
22700 When enabled, DWARF expressions are always printed in an assembly-like\n\
22701 syntax. When disabled, expressions will be printed in a more\n\
22702 conversational style, when possible."),
22704 show_dwarf2_always_disassemble
,
22705 &set_dwarf2_cmdlist
,
22706 &show_dwarf2_cmdlist
);
22708 add_setshow_zuinteger_cmd ("dwarf2-read", no_class
, &dwarf2_read_debug
, _("\
22709 Set debugging of the dwarf2 reader."), _("\
22710 Show debugging of the dwarf2 reader."), _("\
22711 When enabled (non-zero), debugging messages are printed during dwarf2\n\
22712 reading and symtab expansion. A value of 1 (one) provides basic\n\
22713 information. A value greater than 1 provides more verbose information."),
22716 &setdebuglist
, &showdebuglist
);
22718 add_setshow_zuinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
22719 Set debugging of the dwarf2 DIE reader."), _("\
22720 Show debugging of the dwarf2 DIE reader."), _("\
22721 When enabled (non-zero), DIEs are dumped after they are read in.\n\
22722 The value is the maximum depth to print."),
22725 &setdebuglist
, &showdebuglist
);
22727 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
22728 Set cross-checking of \"physname\" code against demangler."), _("\
22729 Show cross-checking of \"physname\" code against demangler."), _("\
22730 When enabled, GDB's internal \"physname\" code is checked against\n\
22732 NULL
, show_check_physname
,
22733 &setdebuglist
, &showdebuglist
);
22735 add_setshow_boolean_cmd ("use-deprecated-index-sections",
22736 no_class
, &use_deprecated_index_sections
, _("\
22737 Set whether to use deprecated gdb_index sections."), _("\
22738 Show whether to use deprecated gdb_index sections."), _("\
22739 When enabled, deprecated .gdb_index sections are used anyway.\n\
22740 Normally they are ignored either because of a missing feature or\n\
22741 performance issue.\n\
22742 Warning: This option must be enabled before gdb reads the file."),
22745 &setlist
, &showlist
);
22747 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
22749 Save a gdb-index file.\n\
22750 Usage: save gdb-index DIRECTORY"),
22752 set_cmd_completer (c
, filename_completer
);
22754 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
22755 &dwarf2_locexpr_funcs
);
22756 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
22757 &dwarf2_loclist_funcs
);
22759 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
22760 &dwarf2_block_frame_base_locexpr_funcs
);
22761 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
22762 &dwarf2_block_frame_base_loclist_funcs
);