1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2015 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
40 #include "gdb-demangle.h"
41 #include "expression.h"
42 #include "filenames.h" /* for DOSish file names */
45 #include "complaints.h"
47 #include "dwarf2expr.h"
48 #include "dwarf2loc.h"
49 #include "cp-support.h"
55 #include "typeprint.h"
59 #include "completer.h"
64 #include "gdbcore.h" /* for gnutarget */
65 #include "gdb/gdb-index.h"
70 #include "filestuff.h"
74 #include <sys/types.h>
76 typedef struct symbol
*symbolp
;
79 /* When == 1, print basic high level tracing messages.
80 When > 1, be more verbose.
81 This is in contrast to the low level DIE reading of dwarf_die_debug. */
82 static unsigned int dwarf_read_debug
= 0;
84 /* When non-zero, dump DIEs after they are read in. */
85 static unsigned int dwarf_die_debug
= 0;
87 /* When non-zero, dump line number entries as they are read in. */
88 static unsigned int dwarf_line_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
);
207 int nr_uniq_abbrev_tables
;
209 int nr_symtab_sharers
;
210 int nr_stmt_less_type_units
;
211 int nr_all_type_units_reallocs
;
214 /* Collection of data recorded per objfile.
215 This hangs off of dwarf2_objfile_data_key. */
217 struct dwarf2_per_objfile
219 struct dwarf2_section_info info
;
220 struct dwarf2_section_info abbrev
;
221 struct dwarf2_section_info line
;
222 struct dwarf2_section_info loc
;
223 struct dwarf2_section_info macinfo
;
224 struct dwarf2_section_info macro
;
225 struct dwarf2_section_info str
;
226 struct dwarf2_section_info ranges
;
227 struct dwarf2_section_info addr
;
228 struct dwarf2_section_info frame
;
229 struct dwarf2_section_info eh_frame
;
230 struct dwarf2_section_info gdb_index
;
232 VEC (dwarf2_section_info_def
) *types
;
235 struct objfile
*objfile
;
237 /* Table of all the compilation units. This is used to locate
238 the target compilation unit of a particular reference. */
239 struct dwarf2_per_cu_data
**all_comp_units
;
241 /* The number of compilation units in ALL_COMP_UNITS. */
244 /* The number of .debug_types-related CUs. */
247 /* The number of elements allocated in all_type_units.
248 If there are skeleton-less TUs, we add them to all_type_units lazily. */
249 int n_allocated_type_units
;
251 /* The .debug_types-related CUs (TUs).
252 This is stored in malloc space because we may realloc it. */
253 struct signatured_type
**all_type_units
;
255 /* Table of struct type_unit_group objects.
256 The hash key is the DW_AT_stmt_list value. */
257 htab_t type_unit_groups
;
259 /* A table mapping .debug_types signatures to its signatured_type entry.
260 This is NULL if the .debug_types section hasn't been read in yet. */
261 htab_t signatured_types
;
263 /* Type unit statistics, to see how well the scaling improvements
265 struct tu_stats tu_stats
;
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
;
317 /* Table containing line_header indexed by offset and offset_in_dwz. */
318 htab_t line_header_hash
;
321 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
323 /* Default names of the debugging sections. */
325 /* Note that if the debugging section has been compressed, it might
326 have a name like .zdebug_info. */
328 static const struct dwarf2_debug_sections dwarf2_elf_names
=
330 { ".debug_info", ".zdebug_info" },
331 { ".debug_abbrev", ".zdebug_abbrev" },
332 { ".debug_line", ".zdebug_line" },
333 { ".debug_loc", ".zdebug_loc" },
334 { ".debug_macinfo", ".zdebug_macinfo" },
335 { ".debug_macro", ".zdebug_macro" },
336 { ".debug_str", ".zdebug_str" },
337 { ".debug_ranges", ".zdebug_ranges" },
338 { ".debug_types", ".zdebug_types" },
339 { ".debug_addr", ".zdebug_addr" },
340 { ".debug_frame", ".zdebug_frame" },
341 { ".eh_frame", NULL
},
342 { ".gdb_index", ".zgdb_index" },
346 /* List of DWO/DWP sections. */
348 static const struct dwop_section_names
350 struct dwarf2_section_names abbrev_dwo
;
351 struct dwarf2_section_names info_dwo
;
352 struct dwarf2_section_names line_dwo
;
353 struct dwarf2_section_names loc_dwo
;
354 struct dwarf2_section_names macinfo_dwo
;
355 struct dwarf2_section_names macro_dwo
;
356 struct dwarf2_section_names str_dwo
;
357 struct dwarf2_section_names str_offsets_dwo
;
358 struct dwarf2_section_names types_dwo
;
359 struct dwarf2_section_names cu_index
;
360 struct dwarf2_section_names tu_index
;
364 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
365 { ".debug_info.dwo", ".zdebug_info.dwo" },
366 { ".debug_line.dwo", ".zdebug_line.dwo" },
367 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
368 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
369 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
370 { ".debug_str.dwo", ".zdebug_str.dwo" },
371 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
372 { ".debug_types.dwo", ".zdebug_types.dwo" },
373 { ".debug_cu_index", ".zdebug_cu_index" },
374 { ".debug_tu_index", ".zdebug_tu_index" },
377 /* local data types */
379 /* The data in a compilation unit header, after target2host
380 translation, looks like this. */
381 struct comp_unit_head
385 unsigned char addr_size
;
386 unsigned char signed_addr_p
;
387 sect_offset abbrev_offset
;
389 /* Size of file offsets; either 4 or 8. */
390 unsigned int offset_size
;
392 /* Size of the length field; either 4 or 12. */
393 unsigned int initial_length_size
;
395 /* Offset to the first byte of this compilation unit header in the
396 .debug_info section, for resolving relative reference dies. */
399 /* Offset to first die in this cu from the start of the cu.
400 This will be the first byte following the compilation unit header. */
401 cu_offset first_die_offset
;
404 /* Type used for delaying computation of method physnames.
405 See comments for compute_delayed_physnames. */
406 struct delayed_method_info
408 /* The type to which the method is attached, i.e., its parent class. */
411 /* The index of the method in the type's function fieldlists. */
414 /* The index of the method in the fieldlist. */
417 /* The name of the DIE. */
420 /* The DIE associated with this method. */
421 struct die_info
*die
;
424 typedef struct delayed_method_info delayed_method_info
;
425 DEF_VEC_O (delayed_method_info
);
427 /* Internal state when decoding a particular compilation unit. */
430 /* The objfile containing this compilation unit. */
431 struct objfile
*objfile
;
433 /* The header of the compilation unit. */
434 struct comp_unit_head header
;
436 /* Base address of this compilation unit. */
437 CORE_ADDR base_address
;
439 /* Non-zero if base_address has been set. */
442 /* The language we are debugging. */
443 enum language language
;
444 const struct language_defn
*language_defn
;
446 const char *producer
;
448 /* The generic symbol table building routines have separate lists for
449 file scope symbols and all all other scopes (local scopes). So
450 we need to select the right one to pass to add_symbol_to_list().
451 We do it by keeping a pointer to the correct list in list_in_scope.
453 FIXME: The original dwarf code just treated the file scope as the
454 first local scope, and all other local scopes as nested local
455 scopes, and worked fine. Check to see if we really need to
456 distinguish these in buildsym.c. */
457 struct pending
**list_in_scope
;
459 /* The abbrev table for this CU.
460 Normally this points to the abbrev table in the objfile.
461 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
462 struct abbrev_table
*abbrev_table
;
464 /* Hash table holding all the loaded partial DIEs
465 with partial_die->offset.SECT_OFF as hash. */
468 /* Storage for things with the same lifetime as this read-in compilation
469 unit, including partial DIEs. */
470 struct obstack comp_unit_obstack
;
472 /* When multiple dwarf2_cu structures are living in memory, this field
473 chains them all together, so that they can be released efficiently.
474 We will probably also want a generation counter so that most-recently-used
475 compilation units are cached... */
476 struct dwarf2_per_cu_data
*read_in_chain
;
478 /* Backlink to our per_cu entry. */
479 struct dwarf2_per_cu_data
*per_cu
;
481 /* How many compilation units ago was this CU last referenced? */
484 /* A hash table of DIE cu_offset for following references with
485 die_info->offset.sect_off as hash. */
488 /* Full DIEs if read in. */
489 struct die_info
*dies
;
491 /* A set of pointers to dwarf2_per_cu_data objects for compilation
492 units referenced by this one. Only set during full symbol processing;
493 partial symbol tables do not have dependencies. */
496 /* Header data from the line table, during full symbol processing. */
497 struct line_header
*line_header
;
499 /* A list of methods which need to have physnames computed
500 after all type information has been read. */
501 VEC (delayed_method_info
) *method_list
;
503 /* To be copied to symtab->call_site_htab. */
504 htab_t call_site_htab
;
506 /* Non-NULL if this CU came from a DWO file.
507 There is an invariant here that is important to remember:
508 Except for attributes copied from the top level DIE in the "main"
509 (or "stub") file in preparation for reading the DWO file
510 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
511 Either there isn't a DWO file (in which case this is NULL and the point
512 is moot), or there is and either we're not going to read it (in which
513 case this is NULL) or there is and we are reading it (in which case this
515 struct dwo_unit
*dwo_unit
;
517 /* The DW_AT_addr_base attribute if present, zero otherwise
518 (zero is a valid value though).
519 Note this value comes from the Fission stub CU/TU's DIE. */
522 /* The DW_AT_ranges_base attribute if present, zero otherwise
523 (zero is a valid value though).
524 Note this value comes from the Fission stub CU/TU's DIE.
525 Also note that the value is zero in the non-DWO case so this value can
526 be used without needing to know whether DWO files are in use or not.
527 N.B. This does not apply to DW_AT_ranges appearing in
528 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
529 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
530 DW_AT_ranges_base *would* have to be applied, and we'd have to care
531 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
532 ULONGEST ranges_base
;
534 /* Mark used when releasing cached dies. */
535 unsigned int mark
: 1;
537 /* This CU references .debug_loc. See the symtab->locations_valid field.
538 This test is imperfect as there may exist optimized debug code not using
539 any location list and still facing inlining issues if handled as
540 unoptimized code. For a future better test see GCC PR other/32998. */
541 unsigned int has_loclist
: 1;
543 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
544 if all the producer_is_* fields are valid. This information is cached
545 because profiling CU expansion showed excessive time spent in
546 producer_is_gxx_lt_4_6. */
547 unsigned int checked_producer
: 1;
548 unsigned int producer_is_gxx_lt_4_6
: 1;
549 unsigned int producer_is_gcc_lt_4_3
: 1;
550 unsigned int producer_is_icc
: 1;
552 /* When set, the file that we're processing is known to have
553 debugging info for C++ namespaces. GCC 3.3.x did not produce
554 this information, but later versions do. */
556 unsigned int processing_has_namespace_info
: 1;
559 /* Persistent data held for a compilation unit, even when not
560 processing it. We put a pointer to this structure in the
561 read_symtab_private field of the psymtab. */
563 struct dwarf2_per_cu_data
565 /* The start offset and length of this compilation unit.
566 NOTE: Unlike comp_unit_head.length, this length includes
568 If the DIE refers to a DWO file, this is always of the original die,
573 /* Flag indicating this compilation unit will be read in before
574 any of the current compilation units are processed. */
575 unsigned int queued
: 1;
577 /* This flag will be set when reading partial DIEs if we need to load
578 absolutely all DIEs for this compilation unit, instead of just the ones
579 we think are interesting. It gets set if we look for a DIE in the
580 hash table and don't find it. */
581 unsigned int load_all_dies
: 1;
583 /* Non-zero if this CU is from .debug_types.
584 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
586 unsigned int is_debug_types
: 1;
588 /* Non-zero if this CU is from the .dwz file. */
589 unsigned int is_dwz
: 1;
591 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
592 This flag is only valid if is_debug_types is true.
593 We can't read a CU directly from a DWO file: There are required
594 attributes in the stub. */
595 unsigned int reading_dwo_directly
: 1;
597 /* Non-zero if the TU has been read.
598 This is used to assist the "Stay in DWO Optimization" for Fission:
599 When reading a DWO, it's faster to read TUs from the DWO instead of
600 fetching them from random other DWOs (due to comdat folding).
601 If the TU has already been read, the optimization is unnecessary
602 (and unwise - we don't want to change where gdb thinks the TU lives
604 This flag is only valid if is_debug_types is true. */
605 unsigned int tu_read
: 1;
607 /* The section this CU/TU lives in.
608 If the DIE refers to a DWO file, this is always the original die,
610 struct dwarf2_section_info
*section
;
612 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
613 of the CU cache it gets reset to NULL again. */
614 struct dwarf2_cu
*cu
;
616 /* The corresponding objfile.
617 Normally we can get the objfile from dwarf2_per_objfile.
618 However we can enter this file with just a "per_cu" handle. */
619 struct objfile
*objfile
;
621 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
622 is active. Otherwise, the 'psymtab' field is active. */
625 /* The partial symbol table associated with this compilation unit,
626 or NULL for unread partial units. */
627 struct partial_symtab
*psymtab
;
629 /* Data needed by the "quick" functions. */
630 struct dwarf2_per_cu_quick_data
*quick
;
633 /* The CUs we import using DW_TAG_imported_unit. This is filled in
634 while reading psymtabs, used to compute the psymtab dependencies,
635 and then cleared. Then it is filled in again while reading full
636 symbols, and only deleted when the objfile is destroyed.
638 This is also used to work around a difference between the way gold
639 generates .gdb_index version <=7 and the way gdb does. Arguably this
640 is a gold bug. For symbols coming from TUs, gold records in the index
641 the CU that includes the TU instead of the TU itself. This breaks
642 dw2_lookup_symbol: It assumes that if the index says symbol X lives
643 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
644 will find X. Alas TUs live in their own symtab, so after expanding CU Y
645 we need to look in TU Z to find X. Fortunately, this is akin to
646 DW_TAG_imported_unit, so we just use the same mechanism: For
647 .gdb_index version <=7 this also records the TUs that the CU referred
648 to. Concurrently with this change gdb was modified to emit version 8
649 indices so we only pay a price for gold generated indices.
650 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
651 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
654 /* Entry in the signatured_types hash table. */
656 struct signatured_type
658 /* The "per_cu" object of this type.
659 This struct is used iff per_cu.is_debug_types.
660 N.B.: This is the first member so that it's easy to convert pointers
662 struct dwarf2_per_cu_data per_cu
;
664 /* The type's signature. */
667 /* Offset in the TU of the type's DIE, as read from the TU header.
668 If this TU is a DWO stub and the definition lives in a DWO file
669 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
670 cu_offset type_offset_in_tu
;
672 /* Offset in the section of the type's DIE.
673 If the definition lives in a DWO file, this is the offset in the
674 .debug_types.dwo section.
675 The value is zero until the actual value is known.
676 Zero is otherwise not a valid section offset. */
677 sect_offset type_offset_in_section
;
679 /* Type units are grouped by their DW_AT_stmt_list entry so that they
680 can share them. This points to the containing symtab. */
681 struct type_unit_group
*type_unit_group
;
684 The first time we encounter this type we fully read it in and install it
685 in the symbol tables. Subsequent times we only need the type. */
688 /* Containing DWO unit.
689 This field is valid iff per_cu.reading_dwo_directly. */
690 struct dwo_unit
*dwo_unit
;
693 typedef struct signatured_type
*sig_type_ptr
;
694 DEF_VEC_P (sig_type_ptr
);
696 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
697 This includes type_unit_group and quick_file_names. */
699 struct stmt_list_hash
701 /* The DWO unit this table is from or NULL if there is none. */
702 struct dwo_unit
*dwo_unit
;
704 /* Offset in .debug_line or .debug_line.dwo. */
705 sect_offset line_offset
;
708 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
709 an object of this type. */
711 struct type_unit_group
713 /* dwarf2read.c's main "handle" on a TU symtab.
714 To simplify things we create an artificial CU that "includes" all the
715 type units using this stmt_list so that the rest of the code still has
716 a "per_cu" handle on the symtab.
717 This PER_CU is recognized by having no section. */
718 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
719 struct dwarf2_per_cu_data per_cu
;
721 /* The TUs that share this DW_AT_stmt_list entry.
722 This is added to while parsing type units to build partial symtabs,
723 and is deleted afterwards and not used again. */
724 VEC (sig_type_ptr
) *tus
;
726 /* The compunit symtab.
727 Type units in a group needn't all be defined in the same source file,
728 so we create an essentially anonymous symtab as the compunit symtab. */
729 struct compunit_symtab
*compunit_symtab
;
731 /* The data used to construct the hash key. */
732 struct stmt_list_hash hash
;
734 /* The number of symtabs from the line header.
735 The value here must match line_header.num_file_names. */
736 unsigned int num_symtabs
;
738 /* The symbol tables for this TU (obtained from the files listed in
740 WARNING: The order of entries here must match the order of entries
741 in the line header. After the first TU using this type_unit_group, the
742 line header for the subsequent TUs is recreated from this. This is done
743 because we need to use the same symtabs for each TU using the same
744 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
745 there's no guarantee the line header doesn't have duplicate entries. */
746 struct symtab
**symtabs
;
749 /* These sections are what may appear in a (real or virtual) DWO file. */
753 struct dwarf2_section_info abbrev
;
754 struct dwarf2_section_info line
;
755 struct dwarf2_section_info loc
;
756 struct dwarf2_section_info macinfo
;
757 struct dwarf2_section_info macro
;
758 struct dwarf2_section_info str
;
759 struct dwarf2_section_info str_offsets
;
760 /* In the case of a virtual DWO file, these two are unused. */
761 struct dwarf2_section_info info
;
762 VEC (dwarf2_section_info_def
) *types
;
765 /* CUs/TUs in DWP/DWO files. */
769 /* Backlink to the containing struct dwo_file. */
770 struct dwo_file
*dwo_file
;
772 /* The "id" that distinguishes this CU/TU.
773 .debug_info calls this "dwo_id", .debug_types calls this "signature".
774 Since signatures came first, we stick with it for consistency. */
777 /* The section this CU/TU lives in, in the DWO file. */
778 struct dwarf2_section_info
*section
;
780 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
784 /* For types, offset in the type's DIE of the type defined by this TU. */
785 cu_offset type_offset_in_tu
;
788 /* include/dwarf2.h defines the DWP section codes.
789 It defines a max value but it doesn't define a min value, which we
790 use for error checking, so provide one. */
792 enum dwp_v2_section_ids
797 /* Data for one DWO file.
799 This includes virtual DWO files (a virtual DWO file is a DWO file as it
800 appears in a DWP file). DWP files don't really have DWO files per se -
801 comdat folding of types "loses" the DWO file they came from, and from
802 a high level view DWP files appear to contain a mass of random types.
803 However, to maintain consistency with the non-DWP case we pretend DWP
804 files contain virtual DWO files, and we assign each TU with one virtual
805 DWO file (generally based on the line and abbrev section offsets -
806 a heuristic that seems to work in practice). */
810 /* The DW_AT_GNU_dwo_name attribute.
811 For virtual DWO files the name is constructed from the section offsets
812 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
813 from related CU+TUs. */
814 const char *dwo_name
;
816 /* The DW_AT_comp_dir attribute. */
817 const char *comp_dir
;
819 /* The bfd, when the file is open. Otherwise this is NULL.
820 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
823 /* The sections that make up this DWO file.
824 Remember that for virtual DWO files in DWP V2, these are virtual
825 sections (for lack of a better name). */
826 struct dwo_sections sections
;
828 /* The CU in the file.
829 We only support one because having more than one requires hacking the
830 dwo_name of each to match, which is highly unlikely to happen.
831 Doing this means all TUs can share comp_dir: We also assume that
832 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
835 /* Table of TUs in the file.
836 Each element is a struct dwo_unit. */
840 /* These sections are what may appear in a DWP file. */
844 /* These are used by both DWP version 1 and 2. */
845 struct dwarf2_section_info str
;
846 struct dwarf2_section_info cu_index
;
847 struct dwarf2_section_info tu_index
;
849 /* These are only used by DWP version 2 files.
850 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
851 sections are referenced by section number, and are not recorded here.
852 In DWP version 2 there is at most one copy of all these sections, each
853 section being (effectively) comprised of the concatenation of all of the
854 individual sections that exist in the version 1 format.
855 To keep the code simple we treat each of these concatenated pieces as a
856 section itself (a virtual section?). */
857 struct dwarf2_section_info abbrev
;
858 struct dwarf2_section_info info
;
859 struct dwarf2_section_info line
;
860 struct dwarf2_section_info loc
;
861 struct dwarf2_section_info macinfo
;
862 struct dwarf2_section_info macro
;
863 struct dwarf2_section_info str_offsets
;
864 struct dwarf2_section_info types
;
867 /* These sections are what may appear in a virtual DWO file in DWP version 1.
868 A virtual DWO file is a DWO file as it appears in a DWP file. */
870 struct virtual_v1_dwo_sections
872 struct dwarf2_section_info abbrev
;
873 struct dwarf2_section_info line
;
874 struct dwarf2_section_info loc
;
875 struct dwarf2_section_info macinfo
;
876 struct dwarf2_section_info macro
;
877 struct dwarf2_section_info str_offsets
;
878 /* Each DWP hash table entry records one CU or one TU.
879 That is recorded here, and copied to dwo_unit.section. */
880 struct dwarf2_section_info info_or_types
;
883 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
884 In version 2, the sections of the DWO files are concatenated together
885 and stored in one section of that name. Thus each ELF section contains
886 several "virtual" sections. */
888 struct virtual_v2_dwo_sections
890 bfd_size_type abbrev_offset
;
891 bfd_size_type abbrev_size
;
893 bfd_size_type line_offset
;
894 bfd_size_type line_size
;
896 bfd_size_type loc_offset
;
897 bfd_size_type loc_size
;
899 bfd_size_type macinfo_offset
;
900 bfd_size_type macinfo_size
;
902 bfd_size_type macro_offset
;
903 bfd_size_type macro_size
;
905 bfd_size_type str_offsets_offset
;
906 bfd_size_type str_offsets_size
;
908 /* Each DWP hash table entry records one CU or one TU.
909 That is recorded here, and copied to dwo_unit.section. */
910 bfd_size_type info_or_types_offset
;
911 bfd_size_type info_or_types_size
;
914 /* Contents of DWP hash tables. */
916 struct dwp_hash_table
918 uint32_t version
, nr_columns
;
919 uint32_t nr_units
, nr_slots
;
920 const gdb_byte
*hash_table
, *unit_table
;
925 const gdb_byte
*indices
;
929 /* This is indexed by column number and gives the id of the section
931 #define MAX_NR_V2_DWO_SECTIONS \
932 (1 /* .debug_info or .debug_types */ \
933 + 1 /* .debug_abbrev */ \
934 + 1 /* .debug_line */ \
935 + 1 /* .debug_loc */ \
936 + 1 /* .debug_str_offsets */ \
937 + 1 /* .debug_macro or .debug_macinfo */)
938 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
939 const gdb_byte
*offsets
;
940 const gdb_byte
*sizes
;
945 /* Data for one DWP file. */
949 /* Name of the file. */
952 /* File format version. */
958 /* Section info for this file. */
959 struct dwp_sections sections
;
961 /* Table of CUs in the file. */
962 const struct dwp_hash_table
*cus
;
964 /* Table of TUs in the file. */
965 const struct dwp_hash_table
*tus
;
967 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
971 /* Table to map ELF section numbers to their sections.
972 This is only needed for the DWP V1 file format. */
973 unsigned int num_sections
;
974 asection
**elf_sections
;
977 /* This represents a '.dwz' file. */
981 /* A dwz file can only contain a few sections. */
982 struct dwarf2_section_info abbrev
;
983 struct dwarf2_section_info info
;
984 struct dwarf2_section_info str
;
985 struct dwarf2_section_info line
;
986 struct dwarf2_section_info macro
;
987 struct dwarf2_section_info gdb_index
;
993 /* Struct used to pass misc. parameters to read_die_and_children, et
994 al. which are used for both .debug_info and .debug_types dies.
995 All parameters here are unchanging for the life of the call. This
996 struct exists to abstract away the constant parameters of die reading. */
998 struct die_reader_specs
1000 /* The bfd of die_section. */
1003 /* The CU of the DIE we are parsing. */
1004 struct dwarf2_cu
*cu
;
1006 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1007 struct dwo_file
*dwo_file
;
1009 /* The section the die comes from.
1010 This is either .debug_info or .debug_types, or the .dwo variants. */
1011 struct dwarf2_section_info
*die_section
;
1013 /* die_section->buffer. */
1014 const gdb_byte
*buffer
;
1016 /* The end of the buffer. */
1017 const gdb_byte
*buffer_end
;
1019 /* The value of the DW_AT_comp_dir attribute. */
1020 const char *comp_dir
;
1023 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1024 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
1025 const gdb_byte
*info_ptr
,
1026 struct die_info
*comp_unit_die
,
1033 unsigned int dir_index
;
1034 unsigned int mod_time
;
1035 unsigned int length
;
1036 /* Non-zero if referenced by the Line Number Program. */
1038 /* The associated symbol table, if any. */
1039 struct symtab
*symtab
;
1042 /* The line number information for a compilation unit (found in the
1043 .debug_line section) begins with a "statement program header",
1044 which contains the following information. */
1047 /* Offset of line number information in .debug_line section. */
1050 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1051 unsigned offset_in_dwz
: 1;
1053 unsigned int total_length
;
1054 unsigned short version
;
1055 unsigned int header_length
;
1056 unsigned char minimum_instruction_length
;
1057 unsigned char maximum_ops_per_instruction
;
1058 unsigned char default_is_stmt
;
1060 unsigned char line_range
;
1061 unsigned char opcode_base
;
1063 /* standard_opcode_lengths[i] is the number of operands for the
1064 standard opcode whose value is i. This means that
1065 standard_opcode_lengths[0] is unused, and the last meaningful
1066 element is standard_opcode_lengths[opcode_base - 1]. */
1067 unsigned char *standard_opcode_lengths
;
1069 /* The include_directories table. NOTE! These strings are not
1070 allocated with xmalloc; instead, they are pointers into
1071 debug_line_buffer. If you try to free them, `free' will get
1073 unsigned int num_include_dirs
, include_dirs_size
;
1074 const char **include_dirs
;
1076 /* The file_names table. NOTE! These strings are not allocated
1077 with xmalloc; instead, they are pointers into debug_line_buffer.
1078 Don't try to free them directly. */
1079 unsigned int num_file_names
, file_names_size
;
1080 struct file_entry
*file_names
;
1082 /* The start and end of the statement program following this
1083 header. These point into dwarf2_per_objfile->line_buffer. */
1084 const gdb_byte
*statement_program_start
, *statement_program_end
;
1087 /* When we construct a partial symbol table entry we only
1088 need this much information. */
1089 struct partial_die_info
1091 /* Offset of this DIE. */
1094 /* DWARF-2 tag for this DIE. */
1095 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1097 /* Assorted flags describing the data found in this DIE. */
1098 unsigned int has_children
: 1;
1099 unsigned int is_external
: 1;
1100 unsigned int is_declaration
: 1;
1101 unsigned int has_type
: 1;
1102 unsigned int has_specification
: 1;
1103 unsigned int has_pc_info
: 1;
1104 unsigned int may_be_inlined
: 1;
1106 /* Flag set if the SCOPE field of this structure has been
1108 unsigned int scope_set
: 1;
1110 /* Flag set if the DIE has a byte_size attribute. */
1111 unsigned int has_byte_size
: 1;
1113 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1114 unsigned int has_const_value
: 1;
1116 /* Flag set if any of the DIE's children are template arguments. */
1117 unsigned int has_template_arguments
: 1;
1119 /* Flag set if fixup_partial_die has been called on this die. */
1120 unsigned int fixup_called
: 1;
1122 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1123 unsigned int is_dwz
: 1;
1125 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1126 unsigned int spec_is_dwz
: 1;
1128 /* The name of this DIE. Normally the value of DW_AT_name, but
1129 sometimes a default name for unnamed DIEs. */
1132 /* The linkage name, if present. */
1133 const char *linkage_name
;
1135 /* The scope to prepend to our children. This is generally
1136 allocated on the comp_unit_obstack, so will disappear
1137 when this compilation unit leaves the cache. */
1140 /* Some data associated with the partial DIE. The tag determines
1141 which field is live. */
1144 /* The location description associated with this DIE, if any. */
1145 struct dwarf_block
*locdesc
;
1146 /* The offset of an import, for DW_TAG_imported_unit. */
1150 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1154 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1155 DW_AT_sibling, if any. */
1156 /* NOTE: This member isn't strictly necessary, read_partial_die could
1157 return DW_AT_sibling values to its caller load_partial_dies. */
1158 const gdb_byte
*sibling
;
1160 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1161 DW_AT_specification (or DW_AT_abstract_origin or
1162 DW_AT_extension). */
1163 sect_offset spec_offset
;
1165 /* Pointers to this DIE's parent, first child, and next sibling,
1167 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
1170 /* This data structure holds the information of an abbrev. */
1173 unsigned int number
; /* number identifying abbrev */
1174 enum dwarf_tag tag
; /* dwarf tag */
1175 unsigned short has_children
; /* boolean */
1176 unsigned short num_attrs
; /* number of attributes */
1177 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1178 struct abbrev_info
*next
; /* next in chain */
1183 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1184 ENUM_BITFIELD(dwarf_form
) form
: 16;
1187 /* Size of abbrev_table.abbrev_hash_table. */
1188 #define ABBREV_HASH_SIZE 121
1190 /* Top level data structure to contain an abbreviation table. */
1194 /* Where the abbrev table came from.
1195 This is used as a sanity check when the table is used. */
1198 /* Storage for the abbrev table. */
1199 struct obstack abbrev_obstack
;
1201 /* Hash table of abbrevs.
1202 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1203 It could be statically allocated, but the previous code didn't so we
1205 struct abbrev_info
**abbrevs
;
1208 /* Attributes have a name and a value. */
1211 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1212 ENUM_BITFIELD(dwarf_form
) form
: 15;
1214 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1215 field should be in u.str (existing only for DW_STRING) but it is kept
1216 here for better struct attribute alignment. */
1217 unsigned int string_is_canonical
: 1;
1222 struct dwarf_block
*blk
;
1231 /* This data structure holds a complete die structure. */
1234 /* DWARF-2 tag for this DIE. */
1235 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1237 /* Number of attributes */
1238 unsigned char num_attrs
;
1240 /* True if we're presently building the full type name for the
1241 type derived from this DIE. */
1242 unsigned char building_fullname
: 1;
1244 /* True if this die is in process. PR 16581. */
1245 unsigned char in_process
: 1;
1248 unsigned int abbrev
;
1250 /* Offset in .debug_info or .debug_types section. */
1253 /* The dies in a compilation unit form an n-ary tree. PARENT
1254 points to this die's parent; CHILD points to the first child of
1255 this node; and all the children of a given node are chained
1256 together via their SIBLING fields. */
1257 struct die_info
*child
; /* Its first child, if any. */
1258 struct die_info
*sibling
; /* Its next sibling, if any. */
1259 struct die_info
*parent
; /* Its parent, if any. */
1261 /* An array of attributes, with NUM_ATTRS elements. There may be
1262 zero, but it's not common and zero-sized arrays are not
1263 sufficiently portable C. */
1264 struct attribute attrs
[1];
1267 /* Get at parts of an attribute structure. */
1269 #define DW_STRING(attr) ((attr)->u.str)
1270 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1271 #define DW_UNSND(attr) ((attr)->u.unsnd)
1272 #define DW_BLOCK(attr) ((attr)->u.blk)
1273 #define DW_SND(attr) ((attr)->u.snd)
1274 #define DW_ADDR(attr) ((attr)->u.addr)
1275 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1277 /* Blocks are a bunch of untyped bytes. */
1282 /* Valid only if SIZE is not zero. */
1283 const gdb_byte
*data
;
1286 #ifndef ATTR_ALLOC_CHUNK
1287 #define ATTR_ALLOC_CHUNK 4
1290 /* Allocate fields for structs, unions and enums in this size. */
1291 #ifndef DW_FIELD_ALLOC_CHUNK
1292 #define DW_FIELD_ALLOC_CHUNK 4
1295 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1296 but this would require a corresponding change in unpack_field_as_long
1298 static int bits_per_byte
= 8;
1302 struct nextfield
*next
;
1310 struct nextfnfield
*next
;
1311 struct fn_field fnfield
;
1318 struct nextfnfield
*head
;
1321 struct typedef_field_list
1323 struct typedef_field field
;
1324 struct typedef_field_list
*next
;
1327 /* The routines that read and process dies for a C struct or C++ class
1328 pass lists of data member fields and lists of member function fields
1329 in an instance of a field_info structure, as defined below. */
1332 /* List of data member and baseclasses fields. */
1333 struct nextfield
*fields
, *baseclasses
;
1335 /* Number of fields (including baseclasses). */
1338 /* Number of baseclasses. */
1341 /* Set if the accesibility of one of the fields is not public. */
1342 int non_public_fields
;
1344 /* Member function fields array, entries are allocated in the order they
1345 are encountered in the object file. */
1346 struct nextfnfield
*fnfields
;
1348 /* Member function fieldlist array, contains name of possibly overloaded
1349 member function, number of overloaded member functions and a pointer
1350 to the head of the member function field chain. */
1351 struct fnfieldlist
*fnfieldlists
;
1353 /* Number of entries in the fnfieldlists array. */
1356 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1357 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1358 struct typedef_field_list
*typedef_field_list
;
1359 unsigned typedef_field_list_count
;
1362 /* One item on the queue of compilation units to read in full symbols
1364 struct dwarf2_queue_item
1366 struct dwarf2_per_cu_data
*per_cu
;
1367 enum language pretend_language
;
1368 struct dwarf2_queue_item
*next
;
1371 /* The current queue. */
1372 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1374 /* Loaded secondary compilation units are kept in memory until they
1375 have not been referenced for the processing of this many
1376 compilation units. Set this to zero to disable caching. Cache
1377 sizes of up to at least twenty will improve startup time for
1378 typical inter-CU-reference binaries, at an obvious memory cost. */
1379 static int dwarf_max_cache_age
= 5;
1381 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1382 struct cmd_list_element
*c
, const char *value
)
1384 fprintf_filtered (file
, _("The upper bound on the age of cached "
1385 "DWARF compilation units is %s.\n"),
1389 /* local function prototypes */
1391 static const char *get_section_name (const struct dwarf2_section_info
*);
1393 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1395 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1397 static void dwarf2_find_base_address (struct die_info
*die
,
1398 struct dwarf2_cu
*cu
);
1400 static struct partial_symtab
*create_partial_symtab
1401 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1403 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1405 static void scan_partial_symbols (struct partial_die_info
*,
1406 CORE_ADDR
*, CORE_ADDR
*,
1407 int, struct dwarf2_cu
*);
1409 static void add_partial_symbol (struct partial_die_info
*,
1410 struct dwarf2_cu
*);
1412 static void add_partial_namespace (struct partial_die_info
*pdi
,
1413 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1414 int set_addrmap
, struct dwarf2_cu
*cu
);
1416 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1417 CORE_ADDR
*highpc
, int set_addrmap
,
1418 struct dwarf2_cu
*cu
);
1420 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1421 struct dwarf2_cu
*cu
);
1423 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1424 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1425 int need_pc
, struct dwarf2_cu
*cu
);
1427 static void dwarf2_read_symtab (struct partial_symtab
*,
1430 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1432 static struct abbrev_info
*abbrev_table_lookup_abbrev
1433 (const struct abbrev_table
*, unsigned int);
1435 static struct abbrev_table
*abbrev_table_read_table
1436 (struct dwarf2_section_info
*, sect_offset
);
1438 static void abbrev_table_free (struct abbrev_table
*);
1440 static void abbrev_table_free_cleanup (void *);
1442 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1443 struct dwarf2_section_info
*);
1445 static void dwarf2_free_abbrev_table (void *);
1447 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1449 static struct partial_die_info
*load_partial_dies
1450 (const struct die_reader_specs
*, const gdb_byte
*, int);
1452 static const gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1453 struct partial_die_info
*,
1454 struct abbrev_info
*,
1458 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1459 struct dwarf2_cu
*);
1461 static void fixup_partial_die (struct partial_die_info
*,
1462 struct dwarf2_cu
*);
1464 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1465 struct attribute
*, struct attr_abbrev
*,
1468 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1470 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1472 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1474 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1476 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1478 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1481 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1483 static LONGEST read_checked_initial_length_and_offset
1484 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1485 unsigned int *, unsigned int *);
1487 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1488 const struct comp_unit_head
*,
1491 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1493 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1496 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1498 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1500 static const char *read_indirect_string (bfd
*, const gdb_byte
*,
1501 const struct comp_unit_head
*,
1504 static const char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1506 static ULONGEST
read_unsigned_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1508 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1510 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1514 static const char *read_str_index (const struct die_reader_specs
*reader
,
1515 ULONGEST str_index
);
1517 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1519 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1520 struct dwarf2_cu
*);
1522 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1525 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1526 struct dwarf2_cu
*cu
);
1528 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1530 static struct die_info
*die_specification (struct die_info
*die
,
1531 struct dwarf2_cu
**);
1533 static void free_line_header (struct line_header
*lh
);
1535 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1536 struct dwarf2_cu
*cu
);
1538 static void dwarf_decode_lines (struct line_header
*, const char *,
1539 struct dwarf2_cu
*, struct partial_symtab
*,
1540 CORE_ADDR
, int decode_mapping
);
1542 static void dwarf2_start_subfile (const char *, const char *);
1544 static struct compunit_symtab
*dwarf2_start_symtab (struct dwarf2_cu
*,
1545 const char *, const char *,
1548 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1549 struct dwarf2_cu
*);
1551 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1552 struct dwarf2_cu
*, struct symbol
*);
1554 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1555 struct dwarf2_cu
*);
1557 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1560 struct obstack
*obstack
,
1561 struct dwarf2_cu
*cu
, LONGEST
*value
,
1562 const gdb_byte
**bytes
,
1563 struct dwarf2_locexpr_baton
**baton
);
1565 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1567 static int need_gnat_info (struct dwarf2_cu
*);
1569 static struct type
*die_descriptive_type (struct die_info
*,
1570 struct dwarf2_cu
*);
1572 static void set_descriptive_type (struct type
*, struct die_info
*,
1573 struct dwarf2_cu
*);
1575 static struct type
*die_containing_type (struct die_info
*,
1576 struct dwarf2_cu
*);
1578 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1579 struct dwarf2_cu
*);
1581 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1583 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1585 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1587 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1588 const char *suffix
, int physname
,
1589 struct dwarf2_cu
*cu
);
1591 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1593 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1595 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1597 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1599 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1601 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1602 struct dwarf2_cu
*, struct partial_symtab
*);
1604 static int dwarf2_get_pc_bounds (struct die_info
*,
1605 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1606 struct partial_symtab
*);
1608 static void get_scope_pc_bounds (struct die_info
*,
1609 CORE_ADDR
*, CORE_ADDR
*,
1610 struct dwarf2_cu
*);
1612 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1613 CORE_ADDR
, struct dwarf2_cu
*);
1615 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1616 struct dwarf2_cu
*);
1618 static void dwarf2_attach_fields_to_type (struct field_info
*,
1619 struct type
*, struct dwarf2_cu
*);
1621 static void dwarf2_add_member_fn (struct field_info
*,
1622 struct die_info
*, struct type
*,
1623 struct dwarf2_cu
*);
1625 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1627 struct dwarf2_cu
*);
1629 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1631 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1633 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1635 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1637 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1639 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1641 static struct type
*read_module_type (struct die_info
*die
,
1642 struct dwarf2_cu
*cu
);
1644 static const char *namespace_name (struct die_info
*die
,
1645 int *is_anonymous
, struct dwarf2_cu
*);
1647 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1649 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1651 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1652 struct dwarf2_cu
*);
1654 static struct die_info
*read_die_and_siblings_1
1655 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1658 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1659 const gdb_byte
*info_ptr
,
1660 const gdb_byte
**new_info_ptr
,
1661 struct die_info
*parent
);
1663 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1664 struct die_info
**, const gdb_byte
*,
1667 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1668 struct die_info
**, const gdb_byte
*,
1671 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1673 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1676 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1678 static const char *dwarf2_full_name (const char *name
,
1679 struct die_info
*die
,
1680 struct dwarf2_cu
*cu
);
1682 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1683 struct dwarf2_cu
*cu
);
1685 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1686 struct dwarf2_cu
**);
1688 static const char *dwarf_tag_name (unsigned int);
1690 static const char *dwarf_attr_name (unsigned int);
1692 static const char *dwarf_form_name (unsigned int);
1694 static char *dwarf_bool_name (unsigned int);
1696 static const char *dwarf_type_encoding_name (unsigned int);
1698 static struct die_info
*sibling_die (struct die_info
*);
1700 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1702 static void dump_die_for_error (struct die_info
*);
1704 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1707 /*static*/ void dump_die (struct die_info
*, int max_level
);
1709 static void store_in_ref_table (struct die_info
*,
1710 struct dwarf2_cu
*);
1712 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1714 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1716 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1717 const struct attribute
*,
1718 struct dwarf2_cu
**);
1720 static struct die_info
*follow_die_ref (struct die_info
*,
1721 const struct attribute
*,
1722 struct dwarf2_cu
**);
1724 static struct die_info
*follow_die_sig (struct die_info
*,
1725 const struct attribute
*,
1726 struct dwarf2_cu
**);
1728 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1729 struct dwarf2_cu
*);
1731 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1732 const struct attribute
*,
1733 struct dwarf2_cu
*);
1735 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1737 static void read_signatured_type (struct signatured_type
*);
1739 /* memory allocation interface */
1741 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1743 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1745 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1747 static int attr_form_is_block (const struct attribute
*);
1749 static int attr_form_is_section_offset (const struct attribute
*);
1751 static int attr_form_is_constant (const struct attribute
*);
1753 static int attr_form_is_ref (const struct attribute
*);
1755 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1756 struct dwarf2_loclist_baton
*baton
,
1757 const struct attribute
*attr
);
1759 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1761 struct dwarf2_cu
*cu
,
1764 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1765 const gdb_byte
*info_ptr
,
1766 struct abbrev_info
*abbrev
);
1768 static void free_stack_comp_unit (void *);
1770 static hashval_t
partial_die_hash (const void *item
);
1772 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1774 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1775 (sect_offset offset
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
1777 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1778 struct dwarf2_per_cu_data
*per_cu
);
1780 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1781 struct die_info
*comp_unit_die
,
1782 enum language pretend_language
);
1784 static void free_heap_comp_unit (void *);
1786 static void free_cached_comp_units (void *);
1788 static void age_cached_comp_units (void);
1790 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1792 static struct type
*set_die_type (struct die_info
*, struct type
*,
1793 struct dwarf2_cu
*);
1795 static void create_all_comp_units (struct objfile
*);
1797 static int create_all_type_units (struct objfile
*);
1799 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1802 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1805 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1808 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1809 struct dwarf2_per_cu_data
*);
1811 static void dwarf2_mark (struct dwarf2_cu
*);
1813 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1815 static struct type
*get_die_type_at_offset (sect_offset
,
1816 struct dwarf2_per_cu_data
*);
1818 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1820 static void dwarf2_release_queue (void *dummy
);
1822 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1823 enum language pretend_language
);
1825 static void process_queue (void);
1827 static void find_file_and_directory (struct die_info
*die
,
1828 struct dwarf2_cu
*cu
,
1829 const char **name
, const char **comp_dir
);
1831 static char *file_full_name (int file
, struct line_header
*lh
,
1832 const char *comp_dir
);
1834 static const gdb_byte
*read_and_check_comp_unit_head
1835 (struct comp_unit_head
*header
,
1836 struct dwarf2_section_info
*section
,
1837 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1838 int is_debug_types_section
);
1840 static void init_cutu_and_read_dies
1841 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1842 int use_existing_cu
, int keep
,
1843 die_reader_func_ftype
*die_reader_func
, void *data
);
1845 static void init_cutu_and_read_dies_simple
1846 (struct dwarf2_per_cu_data
*this_cu
,
1847 die_reader_func_ftype
*die_reader_func
, void *data
);
1849 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1851 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1853 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1854 (struct dwp_file
*dwp_file
, const char *comp_dir
,
1855 ULONGEST signature
, int is_debug_types
);
1857 static struct dwp_file
*get_dwp_file (void);
1859 static struct dwo_unit
*lookup_dwo_comp_unit
1860 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1862 static struct dwo_unit
*lookup_dwo_type_unit
1863 (struct signatured_type
*, const char *, const char *);
1865 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
1867 static void free_dwo_file_cleanup (void *);
1869 static void process_cu_includes (void);
1871 static void check_producer (struct dwarf2_cu
*cu
);
1873 static void free_line_header_voidp (void *arg
);
1875 /* Various complaints about symbol reading that don't abort the process. */
1878 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1880 complaint (&symfile_complaints
,
1881 _("statement list doesn't fit in .debug_line section"));
1885 dwarf2_debug_line_missing_file_complaint (void)
1887 complaint (&symfile_complaints
,
1888 _(".debug_line section has line data without a file"));
1892 dwarf2_debug_line_missing_end_sequence_complaint (void)
1894 complaint (&symfile_complaints
,
1895 _(".debug_line section has line "
1896 "program sequence without an end"));
1900 dwarf2_complex_location_expr_complaint (void)
1902 complaint (&symfile_complaints
, _("location expression too complex"));
1906 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1909 complaint (&symfile_complaints
,
1910 _("const value length mismatch for '%s', got %d, expected %d"),
1915 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1917 complaint (&symfile_complaints
,
1918 _("debug info runs off end of %s section"
1920 get_section_name (section
),
1921 get_section_file_name (section
));
1925 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1927 complaint (&symfile_complaints
,
1928 _("macro debug info contains a "
1929 "malformed macro definition:\n`%s'"),
1934 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1936 complaint (&symfile_complaints
,
1937 _("invalid attribute class or form for '%s' in '%s'"),
1941 /* Hash function for line_header_hash. */
1944 line_header_hash (const struct line_header
*ofs
)
1946 return ofs
->offset
.sect_off
^ ofs
->offset_in_dwz
;
1949 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1952 line_header_hash_voidp (const void *item
)
1954 const struct line_header
*ofs
= item
;
1956 return line_header_hash (ofs
);
1959 /* Equality function for line_header_hash. */
1962 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1964 const struct line_header
*ofs_lhs
= item_lhs
;
1965 const struct line_header
*ofs_rhs
= item_rhs
;
1967 return (ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
1968 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1974 /* Convert VALUE between big- and little-endian. */
1976 byte_swap (offset_type value
)
1980 result
= (value
& 0xff) << 24;
1981 result
|= (value
& 0xff00) << 8;
1982 result
|= (value
& 0xff0000) >> 8;
1983 result
|= (value
& 0xff000000) >> 24;
1987 #define MAYBE_SWAP(V) byte_swap (V)
1990 #define MAYBE_SWAP(V) (V)
1991 #endif /* WORDS_BIGENDIAN */
1993 /* Read the given attribute value as an address, taking the attribute's
1994 form into account. */
1997 attr_value_as_address (struct attribute
*attr
)
2001 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_GNU_addr_index
)
2003 /* Aside from a few clearly defined exceptions, attributes that
2004 contain an address must always be in DW_FORM_addr form.
2005 Unfortunately, some compilers happen to be violating this
2006 requirement by encoding addresses using other forms, such
2007 as DW_FORM_data4 for example. For those broken compilers,
2008 we try to do our best, without any guarantee of success,
2009 to interpret the address correctly. It would also be nice
2010 to generate a complaint, but that would require us to maintain
2011 a list of legitimate cases where a non-address form is allowed,
2012 as well as update callers to pass in at least the CU's DWARF
2013 version. This is more overhead than what we're willing to
2014 expand for a pretty rare case. */
2015 addr
= DW_UNSND (attr
);
2018 addr
= DW_ADDR (attr
);
2023 /* The suffix for an index file. */
2024 #define INDEX_SUFFIX ".gdb-index"
2026 /* Try to locate the sections we need for DWARF 2 debugging
2027 information and return true if we have enough to do something.
2028 NAMES points to the dwarf2 section names, or is NULL if the standard
2029 ELF names are used. */
2032 dwarf2_has_info (struct objfile
*objfile
,
2033 const struct dwarf2_debug_sections
*names
)
2035 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2036 if (!dwarf2_per_objfile
)
2038 /* Initialize per-objfile state. */
2039 struct dwarf2_per_objfile
*data
2040 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
2042 memset (data
, 0, sizeof (*data
));
2043 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
2044 dwarf2_per_objfile
= data
;
2046 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
2048 dwarf2_per_objfile
->objfile
= objfile
;
2050 return (!dwarf2_per_objfile
->info
.is_virtual
2051 && dwarf2_per_objfile
->info
.s
.asection
!= NULL
2052 && !dwarf2_per_objfile
->abbrev
.is_virtual
2053 && dwarf2_per_objfile
->abbrev
.s
.asection
!= NULL
);
2056 /* Return the containing section of virtual section SECTION. */
2058 static struct dwarf2_section_info
*
2059 get_containing_section (const struct dwarf2_section_info
*section
)
2061 gdb_assert (section
->is_virtual
);
2062 return section
->s
.containing_section
;
2065 /* Return the bfd owner of SECTION. */
2068 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2070 if (section
->is_virtual
)
2072 section
= get_containing_section (section
);
2073 gdb_assert (!section
->is_virtual
);
2075 return section
->s
.asection
->owner
;
2078 /* Return the bfd section of SECTION.
2079 Returns NULL if the section is not present. */
2082 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2084 if (section
->is_virtual
)
2086 section
= get_containing_section (section
);
2087 gdb_assert (!section
->is_virtual
);
2089 return section
->s
.asection
;
2092 /* Return the name of SECTION. */
2095 get_section_name (const struct dwarf2_section_info
*section
)
2097 asection
*sectp
= get_section_bfd_section (section
);
2099 gdb_assert (sectp
!= NULL
);
2100 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2103 /* Return the name of the file SECTION is in. */
2106 get_section_file_name (const struct dwarf2_section_info
*section
)
2108 bfd
*abfd
= get_section_bfd_owner (section
);
2110 return bfd_get_filename (abfd
);
2113 /* Return the id of SECTION.
2114 Returns 0 if SECTION doesn't exist. */
2117 get_section_id (const struct dwarf2_section_info
*section
)
2119 asection
*sectp
= get_section_bfd_section (section
);
2126 /* Return the flags of SECTION.
2127 SECTION (or containing section if this is a virtual section) must exist. */
2130 get_section_flags (const struct dwarf2_section_info
*section
)
2132 asection
*sectp
= get_section_bfd_section (section
);
2134 gdb_assert (sectp
!= NULL
);
2135 return bfd_get_section_flags (sectp
->owner
, sectp
);
2138 /* When loading sections, we look either for uncompressed section or for
2139 compressed section names. */
2142 section_is_p (const char *section_name
,
2143 const struct dwarf2_section_names
*names
)
2145 if (names
->normal
!= NULL
2146 && strcmp (section_name
, names
->normal
) == 0)
2148 if (names
->compressed
!= NULL
2149 && strcmp (section_name
, names
->compressed
) == 0)
2154 /* This function is mapped across the sections and remembers the
2155 offset and size of each of the debugging sections we are interested
2159 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
2161 const struct dwarf2_debug_sections
*names
;
2162 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2165 names
= &dwarf2_elf_names
;
2167 names
= (const struct dwarf2_debug_sections
*) vnames
;
2169 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2172 else if (section_is_p (sectp
->name
, &names
->info
))
2174 dwarf2_per_objfile
->info
.s
.asection
= sectp
;
2175 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
2177 else if (section_is_p (sectp
->name
, &names
->abbrev
))
2179 dwarf2_per_objfile
->abbrev
.s
.asection
= sectp
;
2180 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
2182 else if (section_is_p (sectp
->name
, &names
->line
))
2184 dwarf2_per_objfile
->line
.s
.asection
= sectp
;
2185 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
2187 else if (section_is_p (sectp
->name
, &names
->loc
))
2189 dwarf2_per_objfile
->loc
.s
.asection
= sectp
;
2190 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
2192 else if (section_is_p (sectp
->name
, &names
->macinfo
))
2194 dwarf2_per_objfile
->macinfo
.s
.asection
= sectp
;
2195 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
2197 else if (section_is_p (sectp
->name
, &names
->macro
))
2199 dwarf2_per_objfile
->macro
.s
.asection
= sectp
;
2200 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
2202 else if (section_is_p (sectp
->name
, &names
->str
))
2204 dwarf2_per_objfile
->str
.s
.asection
= sectp
;
2205 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
2207 else if (section_is_p (sectp
->name
, &names
->addr
))
2209 dwarf2_per_objfile
->addr
.s
.asection
= sectp
;
2210 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
2212 else if (section_is_p (sectp
->name
, &names
->frame
))
2214 dwarf2_per_objfile
->frame
.s
.asection
= sectp
;
2215 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
2217 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
2219 dwarf2_per_objfile
->eh_frame
.s
.asection
= sectp
;
2220 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
2222 else if (section_is_p (sectp
->name
, &names
->ranges
))
2224 dwarf2_per_objfile
->ranges
.s
.asection
= sectp
;
2225 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
2227 else if (section_is_p (sectp
->name
, &names
->types
))
2229 struct dwarf2_section_info type_section
;
2231 memset (&type_section
, 0, sizeof (type_section
));
2232 type_section
.s
.asection
= sectp
;
2233 type_section
.size
= bfd_get_section_size (sectp
);
2235 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
2238 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
2240 dwarf2_per_objfile
->gdb_index
.s
.asection
= sectp
;
2241 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
2244 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
2245 && bfd_section_vma (abfd
, sectp
) == 0)
2246 dwarf2_per_objfile
->has_section_at_zero
= 1;
2249 /* A helper function that decides whether a section is empty,
2253 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2255 if (section
->is_virtual
)
2256 return section
->size
== 0;
2257 return section
->s
.asection
== NULL
|| section
->size
== 0;
2260 /* Read the contents of the section INFO.
2261 OBJFILE is the main object file, but not necessarily the file where
2262 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2264 If the section is compressed, uncompress it before returning. */
2267 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
2271 gdb_byte
*buf
, *retbuf
;
2275 info
->buffer
= NULL
;
2278 if (dwarf2_section_empty_p (info
))
2281 sectp
= get_section_bfd_section (info
);
2283 /* If this is a virtual section we need to read in the real one first. */
2284 if (info
->is_virtual
)
2286 struct dwarf2_section_info
*containing_section
=
2287 get_containing_section (info
);
2289 gdb_assert (sectp
!= NULL
);
2290 if ((sectp
->flags
& SEC_RELOC
) != 0)
2292 error (_("Dwarf Error: DWP format V2 with relocations is not"
2293 " supported in section %s [in module %s]"),
2294 get_section_name (info
), get_section_file_name (info
));
2296 dwarf2_read_section (objfile
, containing_section
);
2297 /* Other code should have already caught virtual sections that don't
2299 gdb_assert (info
->virtual_offset
+ info
->size
2300 <= containing_section
->size
);
2301 /* If the real section is empty or there was a problem reading the
2302 section we shouldn't get here. */
2303 gdb_assert (containing_section
->buffer
!= NULL
);
2304 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2308 /* If the section has relocations, we must read it ourselves.
2309 Otherwise we attach it to the BFD. */
2310 if ((sectp
->flags
& SEC_RELOC
) == 0)
2312 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2316 buf
= obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2319 /* When debugging .o files, we may need to apply relocations; see
2320 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2321 We never compress sections in .o files, so we only need to
2322 try this when the section is not compressed. */
2323 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2326 info
->buffer
= retbuf
;
2330 abfd
= get_section_bfd_owner (info
);
2331 gdb_assert (abfd
!= NULL
);
2333 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2334 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2336 error (_("Dwarf Error: Can't read DWARF data"
2337 " in section %s [in module %s]"),
2338 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2342 /* A helper function that returns the size of a section in a safe way.
2343 If you are positive that the section has been read before using the
2344 size, then it is safe to refer to the dwarf2_section_info object's
2345 "size" field directly. In other cases, you must call this
2346 function, because for compressed sections the size field is not set
2347 correctly until the section has been read. */
2349 static bfd_size_type
2350 dwarf2_section_size (struct objfile
*objfile
,
2351 struct dwarf2_section_info
*info
)
2354 dwarf2_read_section (objfile
, info
);
2358 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2362 dwarf2_get_section_info (struct objfile
*objfile
,
2363 enum dwarf2_section_enum sect
,
2364 asection
**sectp
, const gdb_byte
**bufp
,
2365 bfd_size_type
*sizep
)
2367 struct dwarf2_per_objfile
*data
2368 = objfile_data (objfile
, dwarf2_objfile_data_key
);
2369 struct dwarf2_section_info
*info
;
2371 /* We may see an objfile without any DWARF, in which case we just
2382 case DWARF2_DEBUG_FRAME
:
2383 info
= &data
->frame
;
2385 case DWARF2_EH_FRAME
:
2386 info
= &data
->eh_frame
;
2389 gdb_assert_not_reached ("unexpected section");
2392 dwarf2_read_section (objfile
, info
);
2394 *sectp
= get_section_bfd_section (info
);
2395 *bufp
= info
->buffer
;
2396 *sizep
= info
->size
;
2399 /* A helper function to find the sections for a .dwz file. */
2402 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2404 struct dwz_file
*dwz_file
= arg
;
2406 /* Note that we only support the standard ELF names, because .dwz
2407 is ELF-only (at the time of writing). */
2408 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2410 dwz_file
->abbrev
.s
.asection
= sectp
;
2411 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2413 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2415 dwz_file
->info
.s
.asection
= sectp
;
2416 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2418 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2420 dwz_file
->str
.s
.asection
= sectp
;
2421 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2423 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2425 dwz_file
->line
.s
.asection
= sectp
;
2426 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2428 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2430 dwz_file
->macro
.s
.asection
= sectp
;
2431 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2433 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2435 dwz_file
->gdb_index
.s
.asection
= sectp
;
2436 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2440 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2441 there is no .gnu_debugaltlink section in the file. Error if there
2442 is such a section but the file cannot be found. */
2444 static struct dwz_file
*
2445 dwarf2_get_dwz_file (void)
2449 struct cleanup
*cleanup
;
2450 const char *filename
;
2451 struct dwz_file
*result
;
2452 bfd_size_type buildid_len_arg
;
2456 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2457 return dwarf2_per_objfile
->dwz_file
;
2459 bfd_set_error (bfd_error_no_error
);
2460 data
= bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2461 &buildid_len_arg
, &buildid
);
2464 if (bfd_get_error () == bfd_error_no_error
)
2466 error (_("could not read '.gnu_debugaltlink' section: %s"),
2467 bfd_errmsg (bfd_get_error ()));
2469 cleanup
= make_cleanup (xfree
, data
);
2470 make_cleanup (xfree
, buildid
);
2472 buildid_len
= (size_t) buildid_len_arg
;
2474 filename
= (const char *) data
;
2475 if (!IS_ABSOLUTE_PATH (filename
))
2477 char *abs
= gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2480 make_cleanup (xfree
, abs
);
2481 abs
= ldirname (abs
);
2482 make_cleanup (xfree
, abs
);
2484 rel
= concat (abs
, SLASH_STRING
, filename
, (char *) NULL
);
2485 make_cleanup (xfree
, rel
);
2489 /* First try the file name given in the section. If that doesn't
2490 work, try to use the build-id instead. */
2491 dwz_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2492 if (dwz_bfd
!= NULL
)
2494 if (!build_id_verify (dwz_bfd
, buildid_len
, buildid
))
2496 gdb_bfd_unref (dwz_bfd
);
2501 if (dwz_bfd
== NULL
)
2502 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2504 if (dwz_bfd
== NULL
)
2505 error (_("could not find '.gnu_debugaltlink' file for %s"),
2506 objfile_name (dwarf2_per_objfile
->objfile
));
2508 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2510 result
->dwz_bfd
= dwz_bfd
;
2512 bfd_map_over_sections (dwz_bfd
, locate_dwz_sections
, result
);
2514 do_cleanups (cleanup
);
2516 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, dwz_bfd
);
2517 dwarf2_per_objfile
->dwz_file
= result
;
2521 /* DWARF quick_symbols_functions support. */
2523 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2524 unique line tables, so we maintain a separate table of all .debug_line
2525 derived entries to support the sharing.
2526 All the quick functions need is the list of file names. We discard the
2527 line_header when we're done and don't need to record it here. */
2528 struct quick_file_names
2530 /* The data used to construct the hash key. */
2531 struct stmt_list_hash hash
;
2533 /* The number of entries in file_names, real_names. */
2534 unsigned int num_file_names
;
2536 /* The file names from the line table, after being run through
2538 const char **file_names
;
2540 /* The file names from the line table after being run through
2541 gdb_realpath. These are computed lazily. */
2542 const char **real_names
;
2545 /* When using the index (and thus not using psymtabs), each CU has an
2546 object of this type. This is used to hold information needed by
2547 the various "quick" methods. */
2548 struct dwarf2_per_cu_quick_data
2550 /* The file table. This can be NULL if there was no file table
2551 or it's currently not read in.
2552 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2553 struct quick_file_names
*file_names
;
2555 /* The corresponding symbol table. This is NULL if symbols for this
2556 CU have not yet been read. */
2557 struct compunit_symtab
*compunit_symtab
;
2559 /* A temporary mark bit used when iterating over all CUs in
2560 expand_symtabs_matching. */
2561 unsigned int mark
: 1;
2563 /* True if we've tried to read the file table and found there isn't one.
2564 There will be no point in trying to read it again next time. */
2565 unsigned int no_file_data
: 1;
2568 /* Utility hash function for a stmt_list_hash. */
2571 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2575 if (stmt_list_hash
->dwo_unit
!= NULL
)
2576 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2577 v
+= stmt_list_hash
->line_offset
.sect_off
;
2581 /* Utility equality function for a stmt_list_hash. */
2584 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2585 const struct stmt_list_hash
*rhs
)
2587 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2589 if (lhs
->dwo_unit
!= NULL
2590 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2593 return lhs
->line_offset
.sect_off
== rhs
->line_offset
.sect_off
;
2596 /* Hash function for a quick_file_names. */
2599 hash_file_name_entry (const void *e
)
2601 const struct quick_file_names
*file_data
= e
;
2603 return hash_stmt_list_entry (&file_data
->hash
);
2606 /* Equality function for a quick_file_names. */
2609 eq_file_name_entry (const void *a
, const void *b
)
2611 const struct quick_file_names
*ea
= a
;
2612 const struct quick_file_names
*eb
= b
;
2614 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2617 /* Delete function for a quick_file_names. */
2620 delete_file_name_entry (void *e
)
2622 struct quick_file_names
*file_data
= e
;
2625 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2627 xfree ((void*) file_data
->file_names
[i
]);
2628 if (file_data
->real_names
)
2629 xfree ((void*) file_data
->real_names
[i
]);
2632 /* The space for the struct itself lives on objfile_obstack,
2633 so we don't free it here. */
2636 /* Create a quick_file_names hash table. */
2639 create_quick_file_names_table (unsigned int nr_initial_entries
)
2641 return htab_create_alloc (nr_initial_entries
,
2642 hash_file_name_entry
, eq_file_name_entry
,
2643 delete_file_name_entry
, xcalloc
, xfree
);
2646 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2647 have to be created afterwards. You should call age_cached_comp_units after
2648 processing PER_CU->CU. dw2_setup must have been already called. */
2651 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2653 if (per_cu
->is_debug_types
)
2654 load_full_type_unit (per_cu
);
2656 load_full_comp_unit (per_cu
, language_minimal
);
2658 gdb_assert (per_cu
->cu
!= NULL
);
2660 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2663 /* Read in the symbols for PER_CU. */
2666 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2668 struct cleanup
*back_to
;
2670 /* Skip type_unit_groups, reading the type units they contain
2671 is handled elsewhere. */
2672 if (IS_TYPE_UNIT_GROUP (per_cu
))
2675 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2677 if (dwarf2_per_objfile
->using_index
2678 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2679 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2681 queue_comp_unit (per_cu
, language_minimal
);
2684 /* If we just loaded a CU from a DWO, and we're working with an index
2685 that may badly handle TUs, load all the TUs in that DWO as well.
2686 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2687 if (!per_cu
->is_debug_types
2688 && per_cu
->cu
->dwo_unit
!= NULL
2689 && dwarf2_per_objfile
->index_table
!= NULL
2690 && dwarf2_per_objfile
->index_table
->version
<= 7
2691 /* DWP files aren't supported yet. */
2692 && get_dwp_file () == NULL
)
2693 queue_and_load_all_dwo_tus (per_cu
);
2698 /* Age the cache, releasing compilation units that have not
2699 been used recently. */
2700 age_cached_comp_units ();
2702 do_cleanups (back_to
);
2705 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2706 the objfile from which this CU came. Returns the resulting symbol
2709 static struct compunit_symtab
*
2710 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2712 gdb_assert (dwarf2_per_objfile
->using_index
);
2713 if (!per_cu
->v
.quick
->compunit_symtab
)
2715 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2716 increment_reading_symtab ();
2717 dw2_do_instantiate_symtab (per_cu
);
2718 process_cu_includes ();
2719 do_cleanups (back_to
);
2722 return per_cu
->v
.quick
->compunit_symtab
;
2725 /* Return the CU/TU given its index.
2727 This is intended for loops like:
2729 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2730 + dwarf2_per_objfile->n_type_units); ++i)
2732 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
2738 static struct dwarf2_per_cu_data
*
2739 dw2_get_cutu (int index
)
2741 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2743 index
-= dwarf2_per_objfile
->n_comp_units
;
2744 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
2745 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
2748 return dwarf2_per_objfile
->all_comp_units
[index
];
2751 /* Return the CU given its index.
2752 This differs from dw2_get_cutu in that it's for when you know INDEX
2755 static struct dwarf2_per_cu_data
*
2756 dw2_get_cu (int index
)
2758 gdb_assert (index
>= 0 && index
< dwarf2_per_objfile
->n_comp_units
);
2760 return dwarf2_per_objfile
->all_comp_units
[index
];
2763 /* A helper for create_cus_from_index that handles a given list of
2767 create_cus_from_index_list (struct objfile
*objfile
,
2768 const gdb_byte
*cu_list
, offset_type n_elements
,
2769 struct dwarf2_section_info
*section
,
2775 for (i
= 0; i
< n_elements
; i
+= 2)
2777 struct dwarf2_per_cu_data
*the_cu
;
2778 ULONGEST offset
, length
;
2780 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2781 offset
= extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2782 length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2785 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2786 struct dwarf2_per_cu_data
);
2787 the_cu
->offset
.sect_off
= offset
;
2788 the_cu
->length
= length
;
2789 the_cu
->objfile
= objfile
;
2790 the_cu
->section
= section
;
2791 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2792 struct dwarf2_per_cu_quick_data
);
2793 the_cu
->is_dwz
= is_dwz
;
2794 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
2798 /* Read the CU list from the mapped index, and use it to create all
2799 the CU objects for this objfile. */
2802 create_cus_from_index (struct objfile
*objfile
,
2803 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2804 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2806 struct dwz_file
*dwz
;
2808 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
2809 dwarf2_per_objfile
->all_comp_units
2810 = obstack_alloc (&objfile
->objfile_obstack
,
2811 dwarf2_per_objfile
->n_comp_units
2812 * sizeof (struct dwarf2_per_cu_data
*));
2814 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
2815 &dwarf2_per_objfile
->info
, 0, 0);
2817 if (dwz_elements
== 0)
2820 dwz
= dwarf2_get_dwz_file ();
2821 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
2822 cu_list_elements
/ 2);
2825 /* Create the signatured type hash table from the index. */
2828 create_signatured_type_table_from_index (struct objfile
*objfile
,
2829 struct dwarf2_section_info
*section
,
2830 const gdb_byte
*bytes
,
2831 offset_type elements
)
2834 htab_t sig_types_hash
;
2836 dwarf2_per_objfile
->n_type_units
2837 = dwarf2_per_objfile
->n_allocated_type_units
2839 dwarf2_per_objfile
->all_type_units
2840 = xmalloc (dwarf2_per_objfile
->n_type_units
2841 * sizeof (struct signatured_type
*));
2843 sig_types_hash
= allocate_signatured_type_table (objfile
);
2845 for (i
= 0; i
< elements
; i
+= 3)
2847 struct signatured_type
*sig_type
;
2848 ULONGEST offset
, type_offset_in_tu
, signature
;
2851 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2852 offset
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2853 type_offset_in_tu
= extract_unsigned_integer (bytes
+ 8, 8,
2855 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2858 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2859 struct signatured_type
);
2860 sig_type
->signature
= signature
;
2861 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2862 sig_type
->per_cu
.is_debug_types
= 1;
2863 sig_type
->per_cu
.section
= section
;
2864 sig_type
->per_cu
.offset
.sect_off
= offset
;
2865 sig_type
->per_cu
.objfile
= objfile
;
2866 sig_type
->per_cu
.v
.quick
2867 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2868 struct dwarf2_per_cu_quick_data
);
2870 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2873 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
2876 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2879 /* Read the address map data from the mapped index, and use it to
2880 populate the objfile's psymtabs_addrmap. */
2883 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2885 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2886 const gdb_byte
*iter
, *end
;
2887 struct obstack temp_obstack
;
2888 struct addrmap
*mutable_map
;
2889 struct cleanup
*cleanup
;
2892 obstack_init (&temp_obstack
);
2893 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2894 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2896 iter
= index
->address_table
;
2897 end
= iter
+ index
->address_table_size
;
2899 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2903 ULONGEST hi
, lo
, cu_index
;
2904 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2906 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2908 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2913 complaint (&symfile_complaints
,
2914 _(".gdb_index address table has invalid range (%s - %s)"),
2915 hex_string (lo
), hex_string (hi
));
2919 if (cu_index
>= dwarf2_per_objfile
->n_comp_units
)
2921 complaint (&symfile_complaints
,
2922 _(".gdb_index address table has invalid CU number %u"),
2923 (unsigned) cu_index
);
2927 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
);
2928 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
);
2929 addrmap_set_empty (mutable_map
, lo
, hi
- 1, dw2_get_cutu (cu_index
));
2932 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2933 &objfile
->objfile_obstack
);
2934 do_cleanups (cleanup
);
2937 /* The hash function for strings in the mapped index. This is the same as
2938 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2939 implementation. This is necessary because the hash function is tied to the
2940 format of the mapped index file. The hash values do not have to match with
2943 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2946 mapped_index_string_hash (int index_version
, const void *p
)
2948 const unsigned char *str
= (const unsigned char *) p
;
2952 while ((c
= *str
++) != 0)
2954 if (index_version
>= 5)
2956 r
= r
* 67 + c
- 113;
2962 /* Find a slot in the mapped index INDEX for the object named NAME.
2963 If NAME is found, set *VEC_OUT to point to the CU vector in the
2964 constant pool and return 1. If NAME cannot be found, return 0. */
2967 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2968 offset_type
**vec_out
)
2970 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2972 offset_type slot
, step
;
2973 int (*cmp
) (const char *, const char *);
2975 if (current_language
->la_language
== language_cplus
2976 || current_language
->la_language
== language_java
2977 || current_language
->la_language
== language_fortran
)
2979 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2982 if (strchr (name
, '(') != NULL
)
2984 char *without_params
= cp_remove_params (name
);
2986 if (without_params
!= NULL
)
2988 make_cleanup (xfree
, without_params
);
2989 name
= without_params
;
2994 /* Index version 4 did not support case insensitive searches. But the
2995 indices for case insensitive languages are built in lowercase, therefore
2996 simulate our NAME being searched is also lowercased. */
2997 hash
= mapped_index_string_hash ((index
->version
== 4
2998 && case_sensitivity
== case_sensitive_off
2999 ? 5 : index
->version
),
3002 slot
= hash
& (index
->symbol_table_slots
- 1);
3003 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
3004 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3008 /* Convert a slot number to an offset into the table. */
3009 offset_type i
= 2 * slot
;
3011 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
3013 do_cleanups (back_to
);
3017 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
3018 if (!cmp (name
, str
))
3020 *vec_out
= (offset_type
*) (index
->constant_pool
3021 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
3022 do_cleanups (back_to
);
3026 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
3030 /* A helper function that reads the .gdb_index from SECTION and fills
3031 in MAP. FILENAME is the name of the file containing the section;
3032 it is used for error reporting. DEPRECATED_OK is nonzero if it is
3033 ok to use deprecated sections.
3035 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3036 out parameters that are filled in with information about the CU and
3037 TU lists in the section.
3039 Returns 1 if all went well, 0 otherwise. */
3042 read_index_from_section (struct objfile
*objfile
,
3043 const char *filename
,
3045 struct dwarf2_section_info
*section
,
3046 struct mapped_index
*map
,
3047 const gdb_byte
**cu_list
,
3048 offset_type
*cu_list_elements
,
3049 const gdb_byte
**types_list
,
3050 offset_type
*types_list_elements
)
3052 const gdb_byte
*addr
;
3053 offset_type version
;
3054 offset_type
*metadata
;
3057 if (dwarf2_section_empty_p (section
))
3060 /* Older elfutils strip versions could keep the section in the main
3061 executable while splitting it for the separate debug info file. */
3062 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
3065 dwarf2_read_section (objfile
, section
);
3067 addr
= section
->buffer
;
3068 /* Version check. */
3069 version
= MAYBE_SWAP (*(offset_type
*) addr
);
3070 /* Versions earlier than 3 emitted every copy of a psymbol. This
3071 causes the index to behave very poorly for certain requests. Version 3
3072 contained incomplete addrmap. So, it seems better to just ignore such
3076 static int warning_printed
= 0;
3077 if (!warning_printed
)
3079 warning (_("Skipping obsolete .gdb_index section in %s."),
3081 warning_printed
= 1;
3085 /* Index version 4 uses a different hash function than index version
3088 Versions earlier than 6 did not emit psymbols for inlined
3089 functions. Using these files will cause GDB not to be able to
3090 set breakpoints on inlined functions by name, so we ignore these
3091 indices unless the user has done
3092 "set use-deprecated-index-sections on". */
3093 if (version
< 6 && !deprecated_ok
)
3095 static int warning_printed
= 0;
3096 if (!warning_printed
)
3099 Skipping deprecated .gdb_index section in %s.\n\
3100 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3101 to use the section anyway."),
3103 warning_printed
= 1;
3107 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3108 of the TU (for symbols coming from TUs),
3109 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3110 Plus gold-generated indices can have duplicate entries for global symbols,
3111 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3112 These are just performance bugs, and we can't distinguish gdb-generated
3113 indices from gold-generated ones, so issue no warning here. */
3115 /* Indexes with higher version than the one supported by GDB may be no
3116 longer backward compatible. */
3120 map
->version
= version
;
3121 map
->total_size
= section
->size
;
3123 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3126 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3127 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3131 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3132 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3133 - MAYBE_SWAP (metadata
[i
]))
3137 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3138 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
3139 - MAYBE_SWAP (metadata
[i
]));
3142 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
3143 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
3144 - MAYBE_SWAP (metadata
[i
]))
3145 / (2 * sizeof (offset_type
)));
3148 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3154 /* Read the index file. If everything went ok, initialize the "quick"
3155 elements of all the CUs and return 1. Otherwise, return 0. */
3158 dwarf2_read_index (struct objfile
*objfile
)
3160 struct mapped_index local_map
, *map
;
3161 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3162 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3163 struct dwz_file
*dwz
;
3165 if (!read_index_from_section (objfile
, objfile_name (objfile
),
3166 use_deprecated_index_sections
,
3167 &dwarf2_per_objfile
->gdb_index
, &local_map
,
3168 &cu_list
, &cu_list_elements
,
3169 &types_list
, &types_list_elements
))
3172 /* Don't use the index if it's empty. */
3173 if (local_map
.symbol_table_slots
== 0)
3176 /* If there is a .dwz file, read it so we can get its CU list as
3178 dwz
= dwarf2_get_dwz_file ();
3181 struct mapped_index dwz_map
;
3182 const gdb_byte
*dwz_types_ignore
;
3183 offset_type dwz_types_elements_ignore
;
3185 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
3187 &dwz
->gdb_index
, &dwz_map
,
3188 &dwz_list
, &dwz_list_elements
,
3190 &dwz_types_elements_ignore
))
3192 warning (_("could not read '.gdb_index' section from %s; skipping"),
3193 bfd_get_filename (dwz
->dwz_bfd
));
3198 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
3201 if (types_list_elements
)
3203 struct dwarf2_section_info
*section
;
3205 /* We can only handle a single .debug_types when we have an
3207 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3210 section
= VEC_index (dwarf2_section_info_def
,
3211 dwarf2_per_objfile
->types
, 0);
3213 create_signatured_type_table_from_index (objfile
, section
, types_list
,
3214 types_list_elements
);
3217 create_addrmap_from_index (objfile
, &local_map
);
3219 map
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct mapped_index
));
3222 dwarf2_per_objfile
->index_table
= map
;
3223 dwarf2_per_objfile
->using_index
= 1;
3224 dwarf2_per_objfile
->quick_file_names_table
=
3225 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3230 /* A helper for the "quick" functions which sets the global
3231 dwarf2_per_objfile according to OBJFILE. */
3234 dw2_setup (struct objfile
*objfile
)
3236 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
3237 gdb_assert (dwarf2_per_objfile
);
3240 /* die_reader_func for dw2_get_file_names. */
3243 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3244 const gdb_byte
*info_ptr
,
3245 struct die_info
*comp_unit_die
,
3249 struct dwarf2_cu
*cu
= reader
->cu
;
3250 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3251 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3252 struct dwarf2_per_cu_data
*lh_cu
;
3253 struct line_header
*lh
;
3254 struct attribute
*attr
;
3256 const char *name
, *comp_dir
;
3258 struct quick_file_names
*qfn
;
3259 unsigned int line_offset
;
3261 gdb_assert (! this_cu
->is_debug_types
);
3263 /* Our callers never want to match partial units -- instead they
3264 will match the enclosing full CU. */
3265 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3267 this_cu
->v
.quick
->no_file_data
= 1;
3276 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3279 struct quick_file_names find_entry
;
3281 line_offset
= DW_UNSND (attr
);
3283 /* We may have already read in this line header (TU line header sharing).
3284 If we have we're done. */
3285 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3286 find_entry
.hash
.line_offset
.sect_off
= line_offset
;
3287 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3288 &find_entry
, INSERT
);
3291 lh_cu
->v
.quick
->file_names
= *slot
;
3295 lh
= dwarf_decode_line_header (line_offset
, cu
);
3299 lh_cu
->v
.quick
->no_file_data
= 1;
3303 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
3304 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3305 qfn
->hash
.line_offset
.sect_off
= line_offset
;
3306 gdb_assert (slot
!= NULL
);
3309 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
3311 qfn
->num_file_names
= lh
->num_file_names
;
3312 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
3313 lh
->num_file_names
* sizeof (char *));
3314 for (i
= 0; i
< lh
->num_file_names
; ++i
)
3315 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
3316 qfn
->real_names
= NULL
;
3318 free_line_header (lh
);
3320 lh_cu
->v
.quick
->file_names
= qfn
;
3323 /* A helper for the "quick" functions which attempts to read the line
3324 table for THIS_CU. */
3326 static struct quick_file_names
*
3327 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3329 /* This should never be called for TUs. */
3330 gdb_assert (! this_cu
->is_debug_types
);
3331 /* Nor type unit groups. */
3332 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3334 if (this_cu
->v
.quick
->file_names
!= NULL
)
3335 return this_cu
->v
.quick
->file_names
;
3336 /* If we know there is no line data, no point in looking again. */
3337 if (this_cu
->v
.quick
->no_file_data
)
3340 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3342 if (this_cu
->v
.quick
->no_file_data
)
3344 return this_cu
->v
.quick
->file_names
;
3347 /* A helper for the "quick" functions which computes and caches the
3348 real path for a given file name from the line table. */
3351 dw2_get_real_path (struct objfile
*objfile
,
3352 struct quick_file_names
*qfn
, int index
)
3354 if (qfn
->real_names
== NULL
)
3355 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3356 qfn
->num_file_names
, const char *);
3358 if (qfn
->real_names
[index
] == NULL
)
3359 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
3361 return qfn
->real_names
[index
];
3364 static struct symtab
*
3365 dw2_find_last_source_symtab (struct objfile
*objfile
)
3367 struct compunit_symtab
*cust
;
3370 dw2_setup (objfile
);
3371 index
= dwarf2_per_objfile
->n_comp_units
- 1;
3372 cust
= dw2_instantiate_symtab (dw2_get_cutu (index
));
3375 return compunit_primary_filetab (cust
);
3378 /* Traversal function for dw2_forget_cached_source_info. */
3381 dw2_free_cached_file_names (void **slot
, void *info
)
3383 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3385 if (file_data
->real_names
)
3389 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3391 xfree ((void*) file_data
->real_names
[i
]);
3392 file_data
->real_names
[i
] = NULL
;
3400 dw2_forget_cached_source_info (struct objfile
*objfile
)
3402 dw2_setup (objfile
);
3404 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3405 dw2_free_cached_file_names
, NULL
);
3408 /* Helper function for dw2_map_symtabs_matching_filename that expands
3409 the symtabs and calls the iterator. */
3412 dw2_map_expand_apply (struct objfile
*objfile
,
3413 struct dwarf2_per_cu_data
*per_cu
,
3414 const char *name
, const char *real_path
,
3415 int (*callback
) (struct symtab
*, void *),
3418 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3420 /* Don't visit already-expanded CUs. */
3421 if (per_cu
->v
.quick
->compunit_symtab
)
3424 /* This may expand more than one symtab, and we want to iterate over
3426 dw2_instantiate_symtab (per_cu
);
3428 return iterate_over_some_symtabs (name
, real_path
, callback
, data
,
3429 objfile
->compunit_symtabs
, last_made
);
3432 /* Implementation of the map_symtabs_matching_filename method. */
3435 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
3436 const char *real_path
,
3437 int (*callback
) (struct symtab
*, void *),
3441 const char *name_basename
= lbasename (name
);
3443 dw2_setup (objfile
);
3445 /* The rule is CUs specify all the files, including those used by
3446 any TU, so there's no need to scan TUs here. */
3448 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3451 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3452 struct quick_file_names
*file_data
;
3454 /* We only need to look at symtabs not already expanded. */
3455 if (per_cu
->v
.quick
->compunit_symtab
)
3458 file_data
= dw2_get_file_names (per_cu
);
3459 if (file_data
== NULL
)
3462 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3464 const char *this_name
= file_data
->file_names
[j
];
3465 const char *this_real_name
;
3467 if (compare_filenames_for_search (this_name
, name
))
3469 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3475 /* Before we invoke realpath, which can get expensive when many
3476 files are involved, do a quick comparison of the basenames. */
3477 if (! basenames_may_differ
3478 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3481 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3482 if (compare_filenames_for_search (this_real_name
, name
))
3484 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3490 if (real_path
!= NULL
)
3492 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3493 gdb_assert (IS_ABSOLUTE_PATH (name
));
3494 if (this_real_name
!= NULL
3495 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3497 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3509 /* Struct used to manage iterating over all CUs looking for a symbol. */
3511 struct dw2_symtab_iterator
3513 /* The internalized form of .gdb_index. */
3514 struct mapped_index
*index
;
3515 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3516 int want_specific_block
;
3517 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3518 Unused if !WANT_SPECIFIC_BLOCK. */
3520 /* The kind of symbol we're looking for. */
3522 /* The list of CUs from the index entry of the symbol,
3523 or NULL if not found. */
3525 /* The next element in VEC to look at. */
3527 /* The number of elements in VEC, or zero if there is no match. */
3529 /* Have we seen a global version of the symbol?
3530 If so we can ignore all further global instances.
3531 This is to work around gold/15646, inefficient gold-generated
3536 /* Initialize the index symtab iterator ITER.
3537 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3538 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3541 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3542 struct mapped_index
*index
,
3543 int want_specific_block
,
3548 iter
->index
= index
;
3549 iter
->want_specific_block
= want_specific_block
;
3550 iter
->block_index
= block_index
;
3551 iter
->domain
= domain
;
3553 iter
->global_seen
= 0;
3555 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3556 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3564 /* Return the next matching CU or NULL if there are no more. */
3566 static struct dwarf2_per_cu_data
*
3567 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3569 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3571 offset_type cu_index_and_attrs
=
3572 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3573 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3574 struct dwarf2_per_cu_data
*per_cu
;
3575 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3576 /* This value is only valid for index versions >= 7. */
3577 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3578 gdb_index_symbol_kind symbol_kind
=
3579 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3580 /* Only check the symbol attributes if they're present.
3581 Indices prior to version 7 don't record them,
3582 and indices >= 7 may elide them for certain symbols
3583 (gold does this). */
3585 (iter
->index
->version
>= 7
3586 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3588 /* Don't crash on bad data. */
3589 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3590 + dwarf2_per_objfile
->n_type_units
))
3592 complaint (&symfile_complaints
,
3593 _(".gdb_index entry has bad CU index"
3595 objfile_name (dwarf2_per_objfile
->objfile
));
3599 per_cu
= dw2_get_cutu (cu_index
);
3601 /* Skip if already read in. */
3602 if (per_cu
->v
.quick
->compunit_symtab
)
3605 /* Check static vs global. */
3608 if (iter
->want_specific_block
3609 && want_static
!= is_static
)
3611 /* Work around gold/15646. */
3612 if (!is_static
&& iter
->global_seen
)
3615 iter
->global_seen
= 1;
3618 /* Only check the symbol's kind if it has one. */
3621 switch (iter
->domain
)
3624 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3625 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3626 /* Some types are also in VAR_DOMAIN. */
3627 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3631 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3635 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3650 static struct compunit_symtab
*
3651 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3652 const char *name
, domain_enum domain
)
3654 struct compunit_symtab
*stab_best
= NULL
;
3655 struct mapped_index
*index
;
3657 dw2_setup (objfile
);
3659 index
= dwarf2_per_objfile
->index_table
;
3661 /* index is NULL if OBJF_READNOW. */
3664 struct dw2_symtab_iterator iter
;
3665 struct dwarf2_per_cu_data
*per_cu
;
3667 dw2_symtab_iter_init (&iter
, index
, 1, block_index
, domain
, name
);
3669 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3671 struct symbol
*sym
, *with_opaque
= NULL
;
3672 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
);
3673 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3674 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3676 sym
= block_find_symbol (block
, name
, domain
,
3677 block_find_non_opaque_type_preferred
,
3680 /* Some caution must be observed with overloaded functions
3681 and methods, since the index will not contain any overload
3682 information (but NAME might contain it). */
3685 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
3687 if (with_opaque
!= NULL
3688 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
3691 /* Keep looking through other CUs. */
3699 dw2_print_stats (struct objfile
*objfile
)
3701 int i
, total
, count
;
3703 dw2_setup (objfile
);
3704 total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
3706 for (i
= 0; i
< total
; ++i
)
3708 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3710 if (!per_cu
->v
.quick
->compunit_symtab
)
3713 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3714 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3717 /* This dumps minimal information about the index.
3718 It is called via "mt print objfiles".
3719 One use is to verify .gdb_index has been loaded by the
3720 gdb.dwarf2/gdb-index.exp testcase. */
3723 dw2_dump (struct objfile
*objfile
)
3725 dw2_setup (objfile
);
3726 gdb_assert (dwarf2_per_objfile
->using_index
);
3727 printf_filtered (".gdb_index:");
3728 if (dwarf2_per_objfile
->index_table
!= NULL
)
3730 printf_filtered (" version %d\n",
3731 dwarf2_per_objfile
->index_table
->version
);
3734 printf_filtered (" faked for \"readnow\"\n");
3735 printf_filtered ("\n");
3739 dw2_relocate (struct objfile
*objfile
,
3740 const struct section_offsets
*new_offsets
,
3741 const struct section_offsets
*delta
)
3743 /* There's nothing to relocate here. */
3747 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3748 const char *func_name
)
3750 struct mapped_index
*index
;
3752 dw2_setup (objfile
);
3754 index
= dwarf2_per_objfile
->index_table
;
3756 /* index is NULL if OBJF_READNOW. */
3759 struct dw2_symtab_iterator iter
;
3760 struct dwarf2_per_cu_data
*per_cu
;
3762 /* Note: It doesn't matter what we pass for block_index here. */
3763 dw2_symtab_iter_init (&iter
, index
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
3766 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3767 dw2_instantiate_symtab (per_cu
);
3772 dw2_expand_all_symtabs (struct objfile
*objfile
)
3776 dw2_setup (objfile
);
3778 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3779 + dwarf2_per_objfile
->n_type_units
); ++i
)
3781 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3783 dw2_instantiate_symtab (per_cu
);
3788 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3789 const char *fullname
)
3793 dw2_setup (objfile
);
3795 /* We don't need to consider type units here.
3796 This is only called for examining code, e.g. expand_line_sal.
3797 There can be an order of magnitude (or more) more type units
3798 than comp units, and we avoid them if we can. */
3800 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3803 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3804 struct quick_file_names
*file_data
;
3806 /* We only need to look at symtabs not already expanded. */
3807 if (per_cu
->v
.quick
->compunit_symtab
)
3810 file_data
= dw2_get_file_names (per_cu
);
3811 if (file_data
== NULL
)
3814 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3816 const char *this_fullname
= file_data
->file_names
[j
];
3818 if (filename_cmp (this_fullname
, fullname
) == 0)
3820 dw2_instantiate_symtab (per_cu
);
3828 dw2_map_matching_symbols (struct objfile
*objfile
,
3829 const char * name
, domain_enum domain
,
3831 int (*callback
) (struct block
*,
3832 struct symbol
*, void *),
3833 void *data
, symbol_compare_ftype
*match
,
3834 symbol_compare_ftype
*ordered_compare
)
3836 /* Currently unimplemented; used for Ada. The function can be called if the
3837 current language is Ada for a non-Ada objfile using GNU index. As Ada
3838 does not look for non-Ada symbols this function should just return. */
3842 dw2_expand_symtabs_matching
3843 (struct objfile
*objfile
,
3844 expand_symtabs_file_matcher_ftype
*file_matcher
,
3845 expand_symtabs_symbol_matcher_ftype
*symbol_matcher
,
3846 expand_symtabs_exp_notify_ftype
*expansion_notify
,
3847 enum search_domain kind
,
3852 struct mapped_index
*index
;
3854 dw2_setup (objfile
);
3856 /* index_table is NULL if OBJF_READNOW. */
3857 if (!dwarf2_per_objfile
->index_table
)
3859 index
= dwarf2_per_objfile
->index_table
;
3861 if (file_matcher
!= NULL
)
3863 struct cleanup
*cleanup
;
3864 htab_t visited_found
, visited_not_found
;
3866 visited_found
= htab_create_alloc (10,
3867 htab_hash_pointer
, htab_eq_pointer
,
3868 NULL
, xcalloc
, xfree
);
3869 cleanup
= make_cleanup_htab_delete (visited_found
);
3870 visited_not_found
= htab_create_alloc (10,
3871 htab_hash_pointer
, htab_eq_pointer
,
3872 NULL
, xcalloc
, xfree
);
3873 make_cleanup_htab_delete (visited_not_found
);
3875 /* The rule is CUs specify all the files, including those used by
3876 any TU, so there's no need to scan TUs here. */
3878 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3881 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3882 struct quick_file_names
*file_data
;
3887 per_cu
->v
.quick
->mark
= 0;
3889 /* We only need to look at symtabs not already expanded. */
3890 if (per_cu
->v
.quick
->compunit_symtab
)
3893 file_data
= dw2_get_file_names (per_cu
);
3894 if (file_data
== NULL
)
3897 if (htab_find (visited_not_found
, file_data
) != NULL
)
3899 else if (htab_find (visited_found
, file_data
) != NULL
)
3901 per_cu
->v
.quick
->mark
= 1;
3905 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3907 const char *this_real_name
;
3909 if (file_matcher (file_data
->file_names
[j
], data
, 0))
3911 per_cu
->v
.quick
->mark
= 1;
3915 /* Before we invoke realpath, which can get expensive when many
3916 files are involved, do a quick comparison of the basenames. */
3917 if (!basenames_may_differ
3918 && !file_matcher (lbasename (file_data
->file_names
[j
]),
3922 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3923 if (file_matcher (this_real_name
, data
, 0))
3925 per_cu
->v
.quick
->mark
= 1;
3930 slot
= htab_find_slot (per_cu
->v
.quick
->mark
3932 : visited_not_found
,
3937 do_cleanups (cleanup
);
3940 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
3942 offset_type idx
= 2 * iter
;
3944 offset_type
*vec
, vec_len
, vec_idx
;
3945 int global_seen
= 0;
3949 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
3952 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
3954 if (! (*symbol_matcher
) (name
, data
))
3957 /* The name was matched, now expand corresponding CUs that were
3959 vec
= (offset_type
*) (index
->constant_pool
3960 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
3961 vec_len
= MAYBE_SWAP (vec
[0]);
3962 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
3964 struct dwarf2_per_cu_data
*per_cu
;
3965 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
3966 /* This value is only valid for index versions >= 7. */
3967 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3968 gdb_index_symbol_kind symbol_kind
=
3969 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3970 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3971 /* Only check the symbol attributes if they're present.
3972 Indices prior to version 7 don't record them,
3973 and indices >= 7 may elide them for certain symbols
3974 (gold does this). */
3976 (index
->version
>= 7
3977 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3979 /* Work around gold/15646. */
3982 if (!is_static
&& global_seen
)
3988 /* Only check the symbol's kind if it has one. */
3993 case VARIABLES_DOMAIN
:
3994 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
3997 case FUNCTIONS_DOMAIN
:
3998 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4002 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4010 /* Don't crash on bad data. */
4011 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
4012 + dwarf2_per_objfile
->n_type_units
))
4014 complaint (&symfile_complaints
,
4015 _(".gdb_index entry has bad CU index"
4016 " [in module %s]"), objfile_name (objfile
));
4020 per_cu
= dw2_get_cutu (cu_index
);
4021 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4023 int symtab_was_null
=
4024 (per_cu
->v
.quick
->compunit_symtab
== NULL
);
4026 dw2_instantiate_symtab (per_cu
);
4028 if (expansion_notify
!= NULL
4030 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
4032 expansion_notify (per_cu
->v
.quick
->compunit_symtab
,
4040 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4043 static struct compunit_symtab
*
4044 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4049 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4050 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4053 if (cust
->includes
== NULL
)
4056 for (i
= 0; cust
->includes
[i
]; ++i
)
4058 struct compunit_symtab
*s
= cust
->includes
[i
];
4060 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4068 static struct compunit_symtab
*
4069 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
4070 struct bound_minimal_symbol msymbol
,
4072 struct obj_section
*section
,
4075 struct dwarf2_per_cu_data
*data
;
4076 struct compunit_symtab
*result
;
4078 dw2_setup (objfile
);
4080 if (!objfile
->psymtabs_addrmap
)
4083 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
4087 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
4088 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4089 paddress (get_objfile_arch (objfile
), pc
));
4092 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
),
4094 gdb_assert (result
!= NULL
);
4099 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4100 void *data
, int need_fullname
)
4103 struct cleanup
*cleanup
;
4104 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
4105 NULL
, xcalloc
, xfree
);
4107 cleanup
= make_cleanup_htab_delete (visited
);
4108 dw2_setup (objfile
);
4110 /* The rule is CUs specify all the files, including those used by
4111 any TU, so there's no need to scan TUs here.
4112 We can ignore file names coming from already-expanded CUs. */
4114 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4116 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4118 if (per_cu
->v
.quick
->compunit_symtab
)
4120 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
4123 *slot
= per_cu
->v
.quick
->file_names
;
4127 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4130 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4131 struct quick_file_names
*file_data
;
4134 /* We only need to look at symtabs not already expanded. */
4135 if (per_cu
->v
.quick
->compunit_symtab
)
4138 file_data
= dw2_get_file_names (per_cu
);
4139 if (file_data
== NULL
)
4142 slot
= htab_find_slot (visited
, file_data
, INSERT
);
4145 /* Already visited. */
4150 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4152 const char *this_real_name
;
4155 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
4157 this_real_name
= NULL
;
4158 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
4162 do_cleanups (cleanup
);
4166 dw2_has_symbols (struct objfile
*objfile
)
4171 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4174 dw2_find_last_source_symtab
,
4175 dw2_forget_cached_source_info
,
4176 dw2_map_symtabs_matching_filename
,
4181 dw2_expand_symtabs_for_function
,
4182 dw2_expand_all_symtabs
,
4183 dw2_expand_symtabs_with_fullname
,
4184 dw2_map_matching_symbols
,
4185 dw2_expand_symtabs_matching
,
4186 dw2_find_pc_sect_compunit_symtab
,
4187 dw2_map_symbol_filenames
4190 /* Initialize for reading DWARF for this objfile. Return 0 if this
4191 file will use psymtabs, or 1 if using the GNU index. */
4194 dwarf2_initialize_objfile (struct objfile
*objfile
)
4196 /* If we're about to read full symbols, don't bother with the
4197 indices. In this case we also don't care if some other debug
4198 format is making psymtabs, because they are all about to be
4200 if ((objfile
->flags
& OBJF_READNOW
))
4204 dwarf2_per_objfile
->using_index
= 1;
4205 create_all_comp_units (objfile
);
4206 create_all_type_units (objfile
);
4207 dwarf2_per_objfile
->quick_file_names_table
=
4208 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
4210 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
4211 + dwarf2_per_objfile
->n_type_units
); ++i
)
4213 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4215 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4216 struct dwarf2_per_cu_quick_data
);
4219 /* Return 1 so that gdb sees the "quick" functions. However,
4220 these functions will be no-ops because we will have expanded
4225 if (dwarf2_read_index (objfile
))
4233 /* Build a partial symbol table. */
4236 dwarf2_build_psymtabs (struct objfile
*objfile
)
4239 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
4241 init_psymbol_list (objfile
, 1024);
4246 /* This isn't really ideal: all the data we allocate on the
4247 objfile's obstack is still uselessly kept around. However,
4248 freeing it seems unsafe. */
4249 struct cleanup
*cleanups
= make_cleanup_discard_psymtabs (objfile
);
4251 dwarf2_build_psymtabs_hard (objfile
);
4252 discard_cleanups (cleanups
);
4254 CATCH (except
, RETURN_MASK_ERROR
)
4256 exception_print (gdb_stderr
, except
);
4261 /* Return the total length of the CU described by HEADER. */
4264 get_cu_length (const struct comp_unit_head
*header
)
4266 return header
->initial_length_size
+ header
->length
;
4269 /* Return TRUE if OFFSET is within CU_HEADER. */
4272 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
4274 sect_offset bottom
= { cu_header
->offset
.sect_off
};
4275 sect_offset top
= { cu_header
->offset
.sect_off
+ get_cu_length (cu_header
) };
4277 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
4280 /* Find the base address of the compilation unit for range lists and
4281 location lists. It will normally be specified by DW_AT_low_pc.
4282 In DWARF-3 draft 4, the base address could be overridden by
4283 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4284 compilation units with discontinuous ranges. */
4287 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
4289 struct attribute
*attr
;
4292 cu
->base_address
= 0;
4294 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
4297 cu
->base_address
= attr_value_as_address (attr
);
4302 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4305 cu
->base_address
= attr_value_as_address (attr
);
4311 /* Read in the comp unit header information from the debug_info at info_ptr.
4312 NOTE: This leaves members offset, first_die_offset to be filled in
4315 static const gdb_byte
*
4316 read_comp_unit_head (struct comp_unit_head
*cu_header
,
4317 const gdb_byte
*info_ptr
, bfd
*abfd
)
4320 unsigned int bytes_read
;
4322 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
4323 cu_header
->initial_length_size
= bytes_read
;
4324 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
4325 info_ptr
+= bytes_read
;
4326 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
4328 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
4330 info_ptr
+= bytes_read
;
4331 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
4333 signed_addr
= bfd_get_sign_extend_vma (abfd
);
4334 if (signed_addr
< 0)
4335 internal_error (__FILE__
, __LINE__
,
4336 _("read_comp_unit_head: dwarf from non elf file"));
4337 cu_header
->signed_addr_p
= signed_addr
;
4342 /* Helper function that returns the proper abbrev section for
4345 static struct dwarf2_section_info
*
4346 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
4348 struct dwarf2_section_info
*abbrev
;
4350 if (this_cu
->is_dwz
)
4351 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
4353 abbrev
= &dwarf2_per_objfile
->abbrev
;
4358 /* Subroutine of read_and_check_comp_unit_head and
4359 read_and_check_type_unit_head to simplify them.
4360 Perform various error checking on the header. */
4363 error_check_comp_unit_head (struct comp_unit_head
*header
,
4364 struct dwarf2_section_info
*section
,
4365 struct dwarf2_section_info
*abbrev_section
)
4367 bfd
*abfd
= get_section_bfd_owner (section
);
4368 const char *filename
= get_section_file_name (section
);
4370 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
4371 error (_("Dwarf Error: wrong version in compilation unit header "
4372 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
4375 if (header
->abbrev_offset
.sect_off
4376 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
4377 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4378 "(offset 0x%lx + 6) [in module %s]"),
4379 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
4382 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4383 avoid potential 32-bit overflow. */
4384 if (((unsigned long) header
->offset
.sect_off
+ get_cu_length (header
))
4386 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4387 "(offset 0x%lx + 0) [in module %s]"),
4388 (long) header
->length
, (long) header
->offset
.sect_off
,
4392 /* Read in a CU/TU header and perform some basic error checking.
4393 The contents of the header are stored in HEADER.
4394 The result is a pointer to the start of the first DIE. */
4396 static const gdb_byte
*
4397 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
4398 struct dwarf2_section_info
*section
,
4399 struct dwarf2_section_info
*abbrev_section
,
4400 const gdb_byte
*info_ptr
,
4401 int is_debug_types_section
)
4403 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4404 bfd
*abfd
= get_section_bfd_owner (section
);
4406 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4408 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4410 /* If we're reading a type unit, skip over the signature and
4411 type_offset fields. */
4412 if (is_debug_types_section
)
4413 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
4415 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4417 error_check_comp_unit_head (header
, section
, abbrev_section
);
4422 /* Read in the types comp unit header information from .debug_types entry at
4423 types_ptr. The result is a pointer to one past the end of the header. */
4425 static const gdb_byte
*
4426 read_and_check_type_unit_head (struct comp_unit_head
*header
,
4427 struct dwarf2_section_info
*section
,
4428 struct dwarf2_section_info
*abbrev_section
,
4429 const gdb_byte
*info_ptr
,
4430 ULONGEST
*signature
,
4431 cu_offset
*type_offset_in_tu
)
4433 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4434 bfd
*abfd
= get_section_bfd_owner (section
);
4436 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4438 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4440 /* If we're reading a type unit, skip over the signature and
4441 type_offset fields. */
4442 if (signature
!= NULL
)
4443 *signature
= read_8_bytes (abfd
, info_ptr
);
4445 if (type_offset_in_tu
!= NULL
)
4446 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
4447 header
->offset_size
);
4448 info_ptr
+= header
->offset_size
;
4450 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4452 error_check_comp_unit_head (header
, section
, abbrev_section
);
4457 /* Fetch the abbreviation table offset from a comp or type unit header. */
4460 read_abbrev_offset (struct dwarf2_section_info
*section
,
4463 bfd
*abfd
= get_section_bfd_owner (section
);
4464 const gdb_byte
*info_ptr
;
4465 unsigned int length
, initial_length_size
, offset_size
;
4466 sect_offset abbrev_offset
;
4468 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
4469 info_ptr
= section
->buffer
+ offset
.sect_off
;
4470 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
4471 offset_size
= initial_length_size
== 4 ? 4 : 8;
4472 info_ptr
+= initial_length_size
+ 2 /*version*/;
4473 abbrev_offset
.sect_off
= read_offset_1 (abfd
, info_ptr
, offset_size
);
4474 return abbrev_offset
;
4477 /* Allocate a new partial symtab for file named NAME and mark this new
4478 partial symtab as being an include of PST. */
4481 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
4482 struct objfile
*objfile
)
4484 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
4486 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
4488 /* It shares objfile->objfile_obstack. */
4489 subpst
->dirname
= pst
->dirname
;
4492 subpst
->textlow
= 0;
4493 subpst
->texthigh
= 0;
4495 subpst
->dependencies
= (struct partial_symtab
**)
4496 obstack_alloc (&objfile
->objfile_obstack
,
4497 sizeof (struct partial_symtab
*));
4498 subpst
->dependencies
[0] = pst
;
4499 subpst
->number_of_dependencies
= 1;
4501 subpst
->globals_offset
= 0;
4502 subpst
->n_global_syms
= 0;
4503 subpst
->statics_offset
= 0;
4504 subpst
->n_static_syms
= 0;
4505 subpst
->compunit_symtab
= NULL
;
4506 subpst
->read_symtab
= pst
->read_symtab
;
4509 /* No private part is necessary for include psymtabs. This property
4510 can be used to differentiate between such include psymtabs and
4511 the regular ones. */
4512 subpst
->read_symtab_private
= NULL
;
4515 /* Read the Line Number Program data and extract the list of files
4516 included by the source file represented by PST. Build an include
4517 partial symtab for each of these included files. */
4520 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
4521 struct die_info
*die
,
4522 struct partial_symtab
*pst
)
4524 struct line_header
*lh
= NULL
;
4525 struct attribute
*attr
;
4527 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
4529 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
4531 return; /* No linetable, so no includes. */
4533 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4534 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, pst
->textlow
, 1);
4536 free_line_header (lh
);
4540 hash_signatured_type (const void *item
)
4542 const struct signatured_type
*sig_type
= item
;
4544 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4545 return sig_type
->signature
;
4549 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
4551 const struct signatured_type
*lhs
= item_lhs
;
4552 const struct signatured_type
*rhs
= item_rhs
;
4554 return lhs
->signature
== rhs
->signature
;
4557 /* Allocate a hash table for signatured types. */
4560 allocate_signatured_type_table (struct objfile
*objfile
)
4562 return htab_create_alloc_ex (41,
4563 hash_signatured_type
,
4566 &objfile
->objfile_obstack
,
4567 hashtab_obstack_allocate
,
4568 dummy_obstack_deallocate
);
4571 /* A helper function to add a signatured type CU to a table. */
4574 add_signatured_type_cu_to_table (void **slot
, void *datum
)
4576 struct signatured_type
*sigt
= *slot
;
4577 struct signatured_type
***datap
= datum
;
4585 /* Create the hash table of all entries in the .debug_types
4586 (or .debug_types.dwo) section(s).
4587 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4588 otherwise it is NULL.
4590 The result is a pointer to the hash table or NULL if there are no types.
4592 Note: This function processes DWO files only, not DWP files. */
4595 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
4596 VEC (dwarf2_section_info_def
) *types
)
4598 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4599 htab_t types_htab
= NULL
;
4601 struct dwarf2_section_info
*section
;
4602 struct dwarf2_section_info
*abbrev_section
;
4604 if (VEC_empty (dwarf2_section_info_def
, types
))
4607 abbrev_section
= (dwo_file
!= NULL
4608 ? &dwo_file
->sections
.abbrev
4609 : &dwarf2_per_objfile
->abbrev
);
4611 if (dwarf_read_debug
)
4612 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_types%s for %s:\n",
4613 dwo_file
? ".dwo" : "",
4614 get_section_file_name (abbrev_section
));
4617 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
4621 const gdb_byte
*info_ptr
, *end_ptr
;
4623 dwarf2_read_section (objfile
, section
);
4624 info_ptr
= section
->buffer
;
4626 if (info_ptr
== NULL
)
4629 /* We can't set abfd until now because the section may be empty or
4630 not present, in which case the bfd is unknown. */
4631 abfd
= get_section_bfd_owner (section
);
4633 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4634 because we don't need to read any dies: the signature is in the
4637 end_ptr
= info_ptr
+ section
->size
;
4638 while (info_ptr
< end_ptr
)
4641 cu_offset type_offset_in_tu
;
4643 struct signatured_type
*sig_type
;
4644 struct dwo_unit
*dwo_tu
;
4646 const gdb_byte
*ptr
= info_ptr
;
4647 struct comp_unit_head header
;
4648 unsigned int length
;
4650 offset
.sect_off
= ptr
- section
->buffer
;
4652 /* We need to read the type's signature in order to build the hash
4653 table, but we don't need anything else just yet. */
4655 ptr
= read_and_check_type_unit_head (&header
, section
,
4656 abbrev_section
, ptr
,
4657 &signature
, &type_offset_in_tu
);
4659 length
= get_cu_length (&header
);
4661 /* Skip dummy type units. */
4662 if (ptr
>= info_ptr
+ length
4663 || peek_abbrev_code (abfd
, ptr
) == 0)
4669 if (types_htab
== NULL
)
4672 types_htab
= allocate_dwo_unit_table (objfile
);
4674 types_htab
= allocate_signatured_type_table (objfile
);
4680 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4682 dwo_tu
->dwo_file
= dwo_file
;
4683 dwo_tu
->signature
= signature
;
4684 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
4685 dwo_tu
->section
= section
;
4686 dwo_tu
->offset
= offset
;
4687 dwo_tu
->length
= length
;
4691 /* N.B.: type_offset is not usable if this type uses a DWO file.
4692 The real type_offset is in the DWO file. */
4694 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4695 struct signatured_type
);
4696 sig_type
->signature
= signature
;
4697 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
4698 sig_type
->per_cu
.objfile
= objfile
;
4699 sig_type
->per_cu
.is_debug_types
= 1;
4700 sig_type
->per_cu
.section
= section
;
4701 sig_type
->per_cu
.offset
= offset
;
4702 sig_type
->per_cu
.length
= length
;
4705 slot
= htab_find_slot (types_htab
,
4706 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
4708 gdb_assert (slot
!= NULL
);
4711 sect_offset dup_offset
;
4715 const struct dwo_unit
*dup_tu
= *slot
;
4717 dup_offset
= dup_tu
->offset
;
4721 const struct signatured_type
*dup_tu
= *slot
;
4723 dup_offset
= dup_tu
->per_cu
.offset
;
4726 complaint (&symfile_complaints
,
4727 _("debug type entry at offset 0x%x is duplicate to"
4728 " the entry at offset 0x%x, signature %s"),
4729 offset
.sect_off
, dup_offset
.sect_off
,
4730 hex_string (signature
));
4732 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
4734 if (dwarf_read_debug
> 1)
4735 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature %s\n",
4737 hex_string (signature
));
4746 /* Create the hash table of all entries in the .debug_types section,
4747 and initialize all_type_units.
4748 The result is zero if there is an error (e.g. missing .debug_types section),
4749 otherwise non-zero. */
4752 create_all_type_units (struct objfile
*objfile
)
4755 struct signatured_type
**iter
;
4757 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
4758 if (types_htab
== NULL
)
4760 dwarf2_per_objfile
->signatured_types
= NULL
;
4764 dwarf2_per_objfile
->signatured_types
= types_htab
;
4766 dwarf2_per_objfile
->n_type_units
4767 = dwarf2_per_objfile
->n_allocated_type_units
4768 = htab_elements (types_htab
);
4769 dwarf2_per_objfile
->all_type_units
4770 = xmalloc (dwarf2_per_objfile
->n_type_units
4771 * sizeof (struct signatured_type
*));
4772 iter
= &dwarf2_per_objfile
->all_type_units
[0];
4773 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
4774 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
4775 == dwarf2_per_objfile
->n_type_units
);
4780 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
4781 If SLOT is non-NULL, it is the entry to use in the hash table.
4782 Otherwise we find one. */
4784 static struct signatured_type
*
4785 add_type_unit (ULONGEST sig
, void **slot
)
4787 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4788 int n_type_units
= dwarf2_per_objfile
->n_type_units
;
4789 struct signatured_type
*sig_type
;
4791 gdb_assert (n_type_units
<= dwarf2_per_objfile
->n_allocated_type_units
);
4793 if (n_type_units
> dwarf2_per_objfile
->n_allocated_type_units
)
4795 if (dwarf2_per_objfile
->n_allocated_type_units
== 0)
4796 dwarf2_per_objfile
->n_allocated_type_units
= 1;
4797 dwarf2_per_objfile
->n_allocated_type_units
*= 2;
4798 dwarf2_per_objfile
->all_type_units
4799 = xrealloc (dwarf2_per_objfile
->all_type_units
,
4800 dwarf2_per_objfile
->n_allocated_type_units
4801 * sizeof (struct signatured_type
*));
4802 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
4804 dwarf2_per_objfile
->n_type_units
= n_type_units
;
4806 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4807 struct signatured_type
);
4808 dwarf2_per_objfile
->all_type_units
[n_type_units
- 1] = sig_type
;
4809 sig_type
->signature
= sig
;
4810 sig_type
->per_cu
.is_debug_types
= 1;
4811 if (dwarf2_per_objfile
->using_index
)
4813 sig_type
->per_cu
.v
.quick
=
4814 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4815 struct dwarf2_per_cu_quick_data
);
4820 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4823 gdb_assert (*slot
== NULL
);
4825 /* The rest of sig_type must be filled in by the caller. */
4829 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4830 Fill in SIG_ENTRY with DWO_ENTRY. */
4833 fill_in_sig_entry_from_dwo_entry (struct objfile
*objfile
,
4834 struct signatured_type
*sig_entry
,
4835 struct dwo_unit
*dwo_entry
)
4837 /* Make sure we're not clobbering something we don't expect to. */
4838 gdb_assert (! sig_entry
->per_cu
.queued
);
4839 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
4840 if (dwarf2_per_objfile
->using_index
)
4842 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
4843 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
4846 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
4847 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
4848 gdb_assert (sig_entry
->type_offset_in_section
.sect_off
== 0);
4849 gdb_assert (sig_entry
->type_unit_group
== NULL
);
4850 gdb_assert (sig_entry
->dwo_unit
== NULL
);
4852 sig_entry
->per_cu
.section
= dwo_entry
->section
;
4853 sig_entry
->per_cu
.offset
= dwo_entry
->offset
;
4854 sig_entry
->per_cu
.length
= dwo_entry
->length
;
4855 sig_entry
->per_cu
.reading_dwo_directly
= 1;
4856 sig_entry
->per_cu
.objfile
= objfile
;
4857 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
4858 sig_entry
->dwo_unit
= dwo_entry
;
4861 /* Subroutine of lookup_signatured_type.
4862 If we haven't read the TU yet, create the signatured_type data structure
4863 for a TU to be read in directly from a DWO file, bypassing the stub.
4864 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4865 using .gdb_index, then when reading a CU we want to stay in the DWO file
4866 containing that CU. Otherwise we could end up reading several other DWO
4867 files (due to comdat folding) to process the transitive closure of all the
4868 mentioned TUs, and that can be slow. The current DWO file will have every
4869 type signature that it needs.
4870 We only do this for .gdb_index because in the psymtab case we already have
4871 to read all the DWOs to build the type unit groups. */
4873 static struct signatured_type
*
4874 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4876 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4877 struct dwo_file
*dwo_file
;
4878 struct dwo_unit find_dwo_entry
, *dwo_entry
;
4879 struct signatured_type find_sig_entry
, *sig_entry
;
4882 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4884 /* If TU skeletons have been removed then we may not have read in any
4886 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4888 dwarf2_per_objfile
->signatured_types
4889 = allocate_signatured_type_table (objfile
);
4892 /* We only ever need to read in one copy of a signatured type.
4893 Use the global signatured_types array to do our own comdat-folding
4894 of types. If this is the first time we're reading this TU, and
4895 the TU has an entry in .gdb_index, replace the recorded data from
4896 .gdb_index with this TU. */
4898 find_sig_entry
.signature
= sig
;
4899 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4900 &find_sig_entry
, INSERT
);
4903 /* We can get here with the TU already read, *or* in the process of being
4904 read. Don't reassign the global entry to point to this DWO if that's
4905 the case. Also note that if the TU is already being read, it may not
4906 have come from a DWO, the program may be a mix of Fission-compiled
4907 code and non-Fission-compiled code. */
4909 /* Have we already tried to read this TU?
4910 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4911 needn't exist in the global table yet). */
4912 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
4915 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4916 dwo_unit of the TU itself. */
4917 dwo_file
= cu
->dwo_unit
->dwo_file
;
4919 /* Ok, this is the first time we're reading this TU. */
4920 if (dwo_file
->tus
== NULL
)
4922 find_dwo_entry
.signature
= sig
;
4923 dwo_entry
= htab_find (dwo_file
->tus
, &find_dwo_entry
);
4924 if (dwo_entry
== NULL
)
4927 /* If the global table doesn't have an entry for this TU, add one. */
4928 if (sig_entry
== NULL
)
4929 sig_entry
= add_type_unit (sig
, slot
);
4931 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4932 sig_entry
->per_cu
.tu_read
= 1;
4936 /* Subroutine of lookup_signatured_type.
4937 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4938 then try the DWP file. If the TU stub (skeleton) has been removed then
4939 it won't be in .gdb_index. */
4941 static struct signatured_type
*
4942 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4944 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4945 struct dwp_file
*dwp_file
= get_dwp_file ();
4946 struct dwo_unit
*dwo_entry
;
4947 struct signatured_type find_sig_entry
, *sig_entry
;
4950 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4951 gdb_assert (dwp_file
!= NULL
);
4953 /* If TU skeletons have been removed then we may not have read in any
4955 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4957 dwarf2_per_objfile
->signatured_types
4958 = allocate_signatured_type_table (objfile
);
4961 find_sig_entry
.signature
= sig
;
4962 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4963 &find_sig_entry
, INSERT
);
4966 /* Have we already tried to read this TU?
4967 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4968 needn't exist in the global table yet). */
4969 if (sig_entry
!= NULL
)
4972 if (dwp_file
->tus
== NULL
)
4974 dwo_entry
= lookup_dwo_unit_in_dwp (dwp_file
, NULL
,
4975 sig
, 1 /* is_debug_types */);
4976 if (dwo_entry
== NULL
)
4979 sig_entry
= add_type_unit (sig
, slot
);
4980 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4985 /* Lookup a signature based type for DW_FORM_ref_sig8.
4986 Returns NULL if signature SIG is not present in the table.
4987 It is up to the caller to complain about this. */
4989 static struct signatured_type
*
4990 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4993 && dwarf2_per_objfile
->using_index
)
4995 /* We're in a DWO/DWP file, and we're using .gdb_index.
4996 These cases require special processing. */
4997 if (get_dwp_file () == NULL
)
4998 return lookup_dwo_signatured_type (cu
, sig
);
5000 return lookup_dwp_signatured_type (cu
, sig
);
5004 struct signatured_type find_entry
, *entry
;
5006 if (dwarf2_per_objfile
->signatured_types
== NULL
)
5008 find_entry
.signature
= sig
;
5009 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
5014 /* Low level DIE reading support. */
5016 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
5019 init_cu_die_reader (struct die_reader_specs
*reader
,
5020 struct dwarf2_cu
*cu
,
5021 struct dwarf2_section_info
*section
,
5022 struct dwo_file
*dwo_file
)
5024 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
5025 reader
->abfd
= get_section_bfd_owner (section
);
5027 reader
->dwo_file
= dwo_file
;
5028 reader
->die_section
= section
;
5029 reader
->buffer
= section
->buffer
;
5030 reader
->buffer_end
= section
->buffer
+ section
->size
;
5031 reader
->comp_dir
= NULL
;
5034 /* Subroutine of init_cutu_and_read_dies to simplify it.
5035 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
5036 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
5039 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
5040 from it to the DIE in the DWO. If NULL we are skipping the stub.
5041 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
5042 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
5043 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
5044 STUB_COMP_DIR may be non-NULL.
5045 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
5046 are filled in with the info of the DIE from the DWO file.
5047 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
5048 provided an abbrev table to use.
5049 The result is non-zero if a valid (non-dummy) DIE was found. */
5052 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
5053 struct dwo_unit
*dwo_unit
,
5054 int abbrev_table_provided
,
5055 struct die_info
*stub_comp_unit_die
,
5056 const char *stub_comp_dir
,
5057 struct die_reader_specs
*result_reader
,
5058 const gdb_byte
**result_info_ptr
,
5059 struct die_info
**result_comp_unit_die
,
5060 int *result_has_children
)
5062 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5063 struct dwarf2_cu
*cu
= this_cu
->cu
;
5064 struct dwarf2_section_info
*section
;
5066 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5067 ULONGEST signature
; /* Or dwo_id. */
5068 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
5069 int i
,num_extra_attrs
;
5070 struct dwarf2_section_info
*dwo_abbrev_section
;
5071 struct attribute
*attr
;
5072 struct die_info
*comp_unit_die
;
5074 /* At most one of these may be provided. */
5075 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
5077 /* These attributes aren't processed until later:
5078 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
5079 DW_AT_comp_dir is used now, to find the DWO file, but it is also
5080 referenced later. However, these attributes are found in the stub
5081 which we won't have later. In order to not impose this complication
5082 on the rest of the code, we read them here and copy them to the
5091 if (stub_comp_unit_die
!= NULL
)
5093 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5095 if (! this_cu
->is_debug_types
)
5096 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
5097 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
5098 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
5099 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
5100 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
5102 /* There should be a DW_AT_addr_base attribute here (if needed).
5103 We need the value before we can process DW_FORM_GNU_addr_index. */
5105 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
5107 cu
->addr_base
= DW_UNSND (attr
);
5109 /* There should be a DW_AT_ranges_base attribute here (if needed).
5110 We need the value before we can process DW_AT_ranges. */
5111 cu
->ranges_base
= 0;
5112 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
5114 cu
->ranges_base
= DW_UNSND (attr
);
5116 else if (stub_comp_dir
!= NULL
)
5118 /* Reconstruct the comp_dir attribute to simplify the code below. */
5119 comp_dir
= (struct attribute
*)
5120 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (*comp_dir
));
5121 comp_dir
->name
= DW_AT_comp_dir
;
5122 comp_dir
->form
= DW_FORM_string
;
5123 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
5124 DW_STRING (comp_dir
) = stub_comp_dir
;
5127 /* Set up for reading the DWO CU/TU. */
5128 cu
->dwo_unit
= dwo_unit
;
5129 section
= dwo_unit
->section
;
5130 dwarf2_read_section (objfile
, section
);
5131 abfd
= get_section_bfd_owner (section
);
5132 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
5133 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
5134 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
5136 if (this_cu
->is_debug_types
)
5138 ULONGEST header_signature
;
5139 cu_offset type_offset_in_tu
;
5140 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
5142 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5146 &type_offset_in_tu
);
5147 /* This is not an assert because it can be caused by bad debug info. */
5148 if (sig_type
->signature
!= header_signature
)
5150 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5151 " TU at offset 0x%x [in module %s]"),
5152 hex_string (sig_type
->signature
),
5153 hex_string (header_signature
),
5154 dwo_unit
->offset
.sect_off
,
5155 bfd_get_filename (abfd
));
5157 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5158 /* For DWOs coming from DWP files, we don't know the CU length
5159 nor the type's offset in the TU until now. */
5160 dwo_unit
->length
= get_cu_length (&cu
->header
);
5161 dwo_unit
->type_offset_in_tu
= type_offset_in_tu
;
5163 /* Establish the type offset that can be used to lookup the type.
5164 For DWO files, we don't know it until now. */
5165 sig_type
->type_offset_in_section
.sect_off
=
5166 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
5170 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5173 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5174 /* For DWOs coming from DWP files, we don't know the CU length
5176 dwo_unit
->length
= get_cu_length (&cu
->header
);
5179 /* Replace the CU's original abbrev table with the DWO's.
5180 Reminder: We can't read the abbrev table until we've read the header. */
5181 if (abbrev_table_provided
)
5183 /* Don't free the provided abbrev table, the caller of
5184 init_cutu_and_read_dies owns it. */
5185 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5186 /* Ensure the DWO abbrev table gets freed. */
5187 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5191 dwarf2_free_abbrev_table (cu
);
5192 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5193 /* Leave any existing abbrev table cleanup as is. */
5196 /* Read in the die, but leave space to copy over the attributes
5197 from the stub. This has the benefit of simplifying the rest of
5198 the code - all the work to maintain the illusion of a single
5199 DW_TAG_{compile,type}_unit DIE is done here. */
5200 num_extra_attrs
= ((stmt_list
!= NULL
)
5204 + (comp_dir
!= NULL
));
5205 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
5206 result_has_children
, num_extra_attrs
);
5208 /* Copy over the attributes from the stub to the DIE we just read in. */
5209 comp_unit_die
= *result_comp_unit_die
;
5210 i
= comp_unit_die
->num_attrs
;
5211 if (stmt_list
!= NULL
)
5212 comp_unit_die
->attrs
[i
++] = *stmt_list
;
5214 comp_unit_die
->attrs
[i
++] = *low_pc
;
5215 if (high_pc
!= NULL
)
5216 comp_unit_die
->attrs
[i
++] = *high_pc
;
5218 comp_unit_die
->attrs
[i
++] = *ranges
;
5219 if (comp_dir
!= NULL
)
5220 comp_unit_die
->attrs
[i
++] = *comp_dir
;
5221 comp_unit_die
->num_attrs
+= num_extra_attrs
;
5223 if (dwarf_die_debug
)
5225 fprintf_unfiltered (gdb_stdlog
,
5226 "Read die from %s@0x%x of %s:\n",
5227 get_section_name (section
),
5228 (unsigned) (begin_info_ptr
- section
->buffer
),
5229 bfd_get_filename (abfd
));
5230 dump_die (comp_unit_die
, dwarf_die_debug
);
5233 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5234 TUs by skipping the stub and going directly to the entry in the DWO file.
5235 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5236 to get it via circuitous means. Blech. */
5237 if (comp_dir
!= NULL
)
5238 result_reader
->comp_dir
= DW_STRING (comp_dir
);
5240 /* Skip dummy compilation units. */
5241 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
5242 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5245 *result_info_ptr
= info_ptr
;
5249 /* Subroutine of init_cutu_and_read_dies to simplify it.
5250 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5251 Returns NULL if the specified DWO unit cannot be found. */
5253 static struct dwo_unit
*
5254 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
5255 struct die_info
*comp_unit_die
)
5257 struct dwarf2_cu
*cu
= this_cu
->cu
;
5258 struct attribute
*attr
;
5260 struct dwo_unit
*dwo_unit
;
5261 const char *comp_dir
, *dwo_name
;
5263 gdb_assert (cu
!= NULL
);
5265 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5266 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5267 gdb_assert (attr
!= NULL
);
5268 dwo_name
= DW_STRING (attr
);
5270 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5272 comp_dir
= DW_STRING (attr
);
5274 if (this_cu
->is_debug_types
)
5276 struct signatured_type
*sig_type
;
5278 /* Since this_cu is the first member of struct signatured_type,
5279 we can go from a pointer to one to a pointer to the other. */
5280 sig_type
= (struct signatured_type
*) this_cu
;
5281 signature
= sig_type
->signature
;
5282 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
5286 struct attribute
*attr
;
5288 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
5290 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5292 dwo_name
, objfile_name (this_cu
->objfile
));
5293 signature
= DW_UNSND (attr
);
5294 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
5301 /* Subroutine of init_cutu_and_read_dies to simplify it.
5302 See it for a description of the parameters.
5303 Read a TU directly from a DWO file, bypassing the stub.
5305 Note: This function could be a little bit simpler if we shared cleanups
5306 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
5307 to do, so we keep this function self-contained. Or we could move this
5308 into our caller, but it's complex enough already. */
5311 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
5312 int use_existing_cu
, int keep
,
5313 die_reader_func_ftype
*die_reader_func
,
5316 struct dwarf2_cu
*cu
;
5317 struct signatured_type
*sig_type
;
5318 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5319 struct die_reader_specs reader
;
5320 const gdb_byte
*info_ptr
;
5321 struct die_info
*comp_unit_die
;
5324 /* Verify we can do the following downcast, and that we have the
5326 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
5327 sig_type
= (struct signatured_type
*) this_cu
;
5328 gdb_assert (sig_type
->dwo_unit
!= NULL
);
5330 cleanups
= make_cleanup (null_cleanup
, NULL
);
5332 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5334 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
5336 /* There's no need to do the rereading_dwo_cu handling that
5337 init_cutu_and_read_dies does since we don't read the stub. */
5341 /* If !use_existing_cu, this_cu->cu must be NULL. */
5342 gdb_assert (this_cu
->cu
== NULL
);
5343 cu
= xmalloc (sizeof (*cu
));
5344 init_one_comp_unit (cu
, this_cu
);
5345 /* If an error occurs while loading, release our storage. */
5346 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5349 /* A future optimization, if needed, would be to use an existing
5350 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
5351 could share abbrev tables. */
5353 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
5354 0 /* abbrev_table_provided */,
5355 NULL
/* stub_comp_unit_die */,
5356 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
5358 &comp_unit_die
, &has_children
) == 0)
5361 do_cleanups (cleanups
);
5365 /* All the "real" work is done here. */
5366 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5368 /* This duplicates the code in init_cutu_and_read_dies,
5369 but the alternative is making the latter more complex.
5370 This function is only for the special case of using DWO files directly:
5371 no point in overly complicating the general case just to handle this. */
5372 if (free_cu_cleanup
!= NULL
)
5376 /* We've successfully allocated this compilation unit. Let our
5377 caller clean it up when finished with it. */
5378 discard_cleanups (free_cu_cleanup
);
5380 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5381 So we have to manually free the abbrev table. */
5382 dwarf2_free_abbrev_table (cu
);
5384 /* Link this CU into read_in_chain. */
5385 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5386 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5389 do_cleanups (free_cu_cleanup
);
5392 do_cleanups (cleanups
);
5395 /* Initialize a CU (or TU) and read its DIEs.
5396 If the CU defers to a DWO file, read the DWO file as well.
5398 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5399 Otherwise the table specified in the comp unit header is read in and used.
5400 This is an optimization for when we already have the abbrev table.
5402 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5403 Otherwise, a new CU is allocated with xmalloc.
5405 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5406 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5408 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5409 linker) then DIE_READER_FUNC will not get called. */
5412 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
5413 struct abbrev_table
*abbrev_table
,
5414 int use_existing_cu
, int keep
,
5415 die_reader_func_ftype
*die_reader_func
,
5418 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5419 struct dwarf2_section_info
*section
= this_cu
->section
;
5420 bfd
*abfd
= get_section_bfd_owner (section
);
5421 struct dwarf2_cu
*cu
;
5422 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5423 struct die_reader_specs reader
;
5424 struct die_info
*comp_unit_die
;
5426 struct attribute
*attr
;
5427 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5428 struct signatured_type
*sig_type
= NULL
;
5429 struct dwarf2_section_info
*abbrev_section
;
5430 /* Non-zero if CU currently points to a DWO file and we need to
5431 reread it. When this happens we need to reread the skeleton die
5432 before we can reread the DWO file (this only applies to CUs, not TUs). */
5433 int rereading_dwo_cu
= 0;
5435 if (dwarf_die_debug
)
5436 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5437 this_cu
->is_debug_types
? "type" : "comp",
5438 this_cu
->offset
.sect_off
);
5440 if (use_existing_cu
)
5443 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5444 file (instead of going through the stub), short-circuit all of this. */
5445 if (this_cu
->reading_dwo_directly
)
5447 /* Narrow down the scope of possibilities to have to understand. */
5448 gdb_assert (this_cu
->is_debug_types
);
5449 gdb_assert (abbrev_table
== NULL
);
5450 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
5451 die_reader_func
, data
);
5455 cleanups
= make_cleanup (null_cleanup
, NULL
);
5457 /* This is cheap if the section is already read in. */
5458 dwarf2_read_section (objfile
, section
);
5460 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5462 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
5464 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5467 /* If this CU is from a DWO file we need to start over, we need to
5468 refetch the attributes from the skeleton CU.
5469 This could be optimized by retrieving those attributes from when we
5470 were here the first time: the previous comp_unit_die was stored in
5471 comp_unit_obstack. But there's no data yet that we need this
5473 if (cu
->dwo_unit
!= NULL
)
5474 rereading_dwo_cu
= 1;
5478 /* If !use_existing_cu, this_cu->cu must be NULL. */
5479 gdb_assert (this_cu
->cu
== NULL
);
5480 cu
= xmalloc (sizeof (*cu
));
5481 init_one_comp_unit (cu
, this_cu
);
5482 /* If an error occurs while loading, release our storage. */
5483 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5486 /* Get the header. */
5487 if (cu
->header
.first_die_offset
.cu_off
!= 0 && ! rereading_dwo_cu
)
5489 /* We already have the header, there's no need to read it in again. */
5490 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
5494 if (this_cu
->is_debug_types
)
5497 cu_offset type_offset_in_tu
;
5499 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5500 abbrev_section
, info_ptr
,
5502 &type_offset_in_tu
);
5504 /* Since per_cu is the first member of struct signatured_type,
5505 we can go from a pointer to one to a pointer to the other. */
5506 sig_type
= (struct signatured_type
*) this_cu
;
5507 gdb_assert (sig_type
->signature
== signature
);
5508 gdb_assert (sig_type
->type_offset_in_tu
.cu_off
5509 == type_offset_in_tu
.cu_off
);
5510 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5512 /* LENGTH has not been set yet for type units if we're
5513 using .gdb_index. */
5514 this_cu
->length
= get_cu_length (&cu
->header
);
5516 /* Establish the type offset that can be used to lookup the type. */
5517 sig_type
->type_offset_in_section
.sect_off
=
5518 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
5522 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5526 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5527 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
5531 /* Skip dummy compilation units. */
5532 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5533 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5535 do_cleanups (cleanups
);
5539 /* If we don't have them yet, read the abbrevs for this compilation unit.
5540 And if we need to read them now, make sure they're freed when we're
5541 done. Note that it's important that if the CU had an abbrev table
5542 on entry we don't free it when we're done: Somewhere up the call stack
5543 it may be in use. */
5544 if (abbrev_table
!= NULL
)
5546 gdb_assert (cu
->abbrev_table
== NULL
);
5547 gdb_assert (cu
->header
.abbrev_offset
.sect_off
5548 == abbrev_table
->offset
.sect_off
);
5549 cu
->abbrev_table
= abbrev_table
;
5551 else if (cu
->abbrev_table
== NULL
)
5553 dwarf2_read_abbrevs (cu
, abbrev_section
);
5554 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5556 else if (rereading_dwo_cu
)
5558 dwarf2_free_abbrev_table (cu
);
5559 dwarf2_read_abbrevs (cu
, abbrev_section
);
5562 /* Read the top level CU/TU die. */
5563 init_cu_die_reader (&reader
, cu
, section
, NULL
);
5564 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5566 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5568 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5569 DWO CU, that this test will fail (the attribute will not be present). */
5570 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5573 struct dwo_unit
*dwo_unit
;
5574 struct die_info
*dwo_comp_unit_die
;
5578 complaint (&symfile_complaints
,
5579 _("compilation unit with DW_AT_GNU_dwo_name"
5580 " has children (offset 0x%x) [in module %s]"),
5581 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
5583 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
5584 if (dwo_unit
!= NULL
)
5586 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
5587 abbrev_table
!= NULL
,
5588 comp_unit_die
, NULL
,
5590 &dwo_comp_unit_die
, &has_children
) == 0)
5593 do_cleanups (cleanups
);
5596 comp_unit_die
= dwo_comp_unit_die
;
5600 /* Yikes, we couldn't find the rest of the DIE, we only have
5601 the stub. A complaint has already been logged. There's
5602 not much more we can do except pass on the stub DIE to
5603 die_reader_func. We don't want to throw an error on bad
5608 /* All of the above is setup for this call. Yikes. */
5609 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5611 /* Done, clean up. */
5612 if (free_cu_cleanup
!= NULL
)
5616 /* We've successfully allocated this compilation unit. Let our
5617 caller clean it up when finished with it. */
5618 discard_cleanups (free_cu_cleanup
);
5620 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5621 So we have to manually free the abbrev table. */
5622 dwarf2_free_abbrev_table (cu
);
5624 /* Link this CU into read_in_chain. */
5625 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5626 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5629 do_cleanups (free_cu_cleanup
);
5632 do_cleanups (cleanups
);
5635 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5636 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5637 to have already done the lookup to find the DWO file).
5639 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5640 THIS_CU->is_debug_types, but nothing else.
5642 We fill in THIS_CU->length.
5644 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5645 linker) then DIE_READER_FUNC will not get called.
5647 THIS_CU->cu is always freed when done.
5648 This is done in order to not leave THIS_CU->cu in a state where we have
5649 to care whether it refers to the "main" CU or the DWO CU. */
5652 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
5653 struct dwo_file
*dwo_file
,
5654 die_reader_func_ftype
*die_reader_func
,
5657 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5658 struct dwarf2_section_info
*section
= this_cu
->section
;
5659 bfd
*abfd
= get_section_bfd_owner (section
);
5660 struct dwarf2_section_info
*abbrev_section
;
5661 struct dwarf2_cu cu
;
5662 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5663 struct die_reader_specs reader
;
5664 struct cleanup
*cleanups
;
5665 struct die_info
*comp_unit_die
;
5668 if (dwarf_die_debug
)
5669 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5670 this_cu
->is_debug_types
? "type" : "comp",
5671 this_cu
->offset
.sect_off
);
5673 gdb_assert (this_cu
->cu
== NULL
);
5675 abbrev_section
= (dwo_file
!= NULL
5676 ? &dwo_file
->sections
.abbrev
5677 : get_abbrev_section_for_cu (this_cu
));
5679 /* This is cheap if the section is already read in. */
5680 dwarf2_read_section (objfile
, section
);
5682 init_one_comp_unit (&cu
, this_cu
);
5684 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
5686 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5687 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
5688 abbrev_section
, info_ptr
,
5689 this_cu
->is_debug_types
);
5691 this_cu
->length
= get_cu_length (&cu
.header
);
5693 /* Skip dummy compilation units. */
5694 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5695 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5697 do_cleanups (cleanups
);
5701 dwarf2_read_abbrevs (&cu
, abbrev_section
);
5702 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
5704 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
5705 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5707 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5709 do_cleanups (cleanups
);
5712 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5713 does not lookup the specified DWO file.
5714 This cannot be used to read DWO files.
5716 THIS_CU->cu is always freed when done.
5717 This is done in order to not leave THIS_CU->cu in a state where we have
5718 to care whether it refers to the "main" CU or the DWO CU.
5719 We can revisit this if the data shows there's a performance issue. */
5722 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
5723 die_reader_func_ftype
*die_reader_func
,
5726 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
5729 /* Type Unit Groups.
5731 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5732 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5733 so that all types coming from the same compilation (.o file) are grouped
5734 together. A future step could be to put the types in the same symtab as
5735 the CU the types ultimately came from. */
5738 hash_type_unit_group (const void *item
)
5740 const struct type_unit_group
*tu_group
= item
;
5742 return hash_stmt_list_entry (&tu_group
->hash
);
5746 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
5748 const struct type_unit_group
*lhs
= item_lhs
;
5749 const struct type_unit_group
*rhs
= item_rhs
;
5751 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
5754 /* Allocate a hash table for type unit groups. */
5757 allocate_type_unit_groups_table (void)
5759 return htab_create_alloc_ex (3,
5760 hash_type_unit_group
,
5763 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
5764 hashtab_obstack_allocate
,
5765 dummy_obstack_deallocate
);
5768 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5769 partial symtabs. We combine several TUs per psymtab to not let the size
5770 of any one psymtab grow too big. */
5771 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5772 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5774 /* Helper routine for get_type_unit_group.
5775 Create the type_unit_group object used to hold one or more TUs. */
5777 static struct type_unit_group
*
5778 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
5780 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5781 struct dwarf2_per_cu_data
*per_cu
;
5782 struct type_unit_group
*tu_group
;
5784 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5785 struct type_unit_group
);
5786 per_cu
= &tu_group
->per_cu
;
5787 per_cu
->objfile
= objfile
;
5789 if (dwarf2_per_objfile
->using_index
)
5791 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5792 struct dwarf2_per_cu_quick_data
);
5796 unsigned int line_offset
= line_offset_struct
.sect_off
;
5797 struct partial_symtab
*pst
;
5800 /* Give the symtab a useful name for debug purposes. */
5801 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
5802 name
= xstrprintf ("<type_units_%d>",
5803 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
5805 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
5807 pst
= create_partial_symtab (per_cu
, name
);
5813 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
5814 tu_group
->hash
.line_offset
= line_offset_struct
;
5819 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5820 STMT_LIST is a DW_AT_stmt_list attribute. */
5822 static struct type_unit_group
*
5823 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
5825 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5826 struct type_unit_group
*tu_group
;
5828 unsigned int line_offset
;
5829 struct type_unit_group type_unit_group_for_lookup
;
5831 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
5833 dwarf2_per_objfile
->type_unit_groups
=
5834 allocate_type_unit_groups_table ();
5837 /* Do we need to create a new group, or can we use an existing one? */
5841 line_offset
= DW_UNSND (stmt_list
);
5842 ++tu_stats
->nr_symtab_sharers
;
5846 /* Ugh, no stmt_list. Rare, but we have to handle it.
5847 We can do various things here like create one group per TU or
5848 spread them over multiple groups to split up the expansion work.
5849 To avoid worst case scenarios (too many groups or too large groups)
5850 we, umm, group them in bunches. */
5851 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5852 | (tu_stats
->nr_stmt_less_type_units
5853 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
5854 ++tu_stats
->nr_stmt_less_type_units
;
5857 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
5858 type_unit_group_for_lookup
.hash
.line_offset
.sect_off
= line_offset
;
5859 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
5860 &type_unit_group_for_lookup
, INSERT
);
5864 gdb_assert (tu_group
!= NULL
);
5868 sect_offset line_offset_struct
;
5870 line_offset_struct
.sect_off
= line_offset
;
5871 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
5873 ++tu_stats
->nr_symtabs
;
5879 /* Partial symbol tables. */
5881 /* Create a psymtab named NAME and assign it to PER_CU.
5883 The caller must fill in the following details:
5884 dirname, textlow, texthigh. */
5886 static struct partial_symtab
*
5887 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
5889 struct objfile
*objfile
= per_cu
->objfile
;
5890 struct partial_symtab
*pst
;
5892 pst
= start_psymtab_common (objfile
, name
, 0,
5893 objfile
->global_psymbols
.next
,
5894 objfile
->static_psymbols
.next
);
5896 pst
->psymtabs_addrmap_supported
= 1;
5898 /* This is the glue that links PST into GDB's symbol API. */
5899 pst
->read_symtab_private
= per_cu
;
5900 pst
->read_symtab
= dwarf2_read_symtab
;
5901 per_cu
->v
.psymtab
= pst
;
5906 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5909 struct process_psymtab_comp_unit_data
5911 /* True if we are reading a DW_TAG_partial_unit. */
5913 int want_partial_unit
;
5915 /* The "pretend" language that is used if the CU doesn't declare a
5918 enum language pretend_language
;
5921 /* die_reader_func for process_psymtab_comp_unit. */
5924 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
5925 const gdb_byte
*info_ptr
,
5926 struct die_info
*comp_unit_die
,
5930 struct dwarf2_cu
*cu
= reader
->cu
;
5931 struct objfile
*objfile
= cu
->objfile
;
5932 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5933 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
5934 struct attribute
*attr
;
5936 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
5937 struct partial_symtab
*pst
;
5939 const char *filename
;
5940 struct process_psymtab_comp_unit_data
*info
= data
;
5942 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
5945 gdb_assert (! per_cu
->is_debug_types
);
5947 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
5949 cu
->list_in_scope
= &file_symbols
;
5951 /* Allocate a new partial symbol table structure. */
5952 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
5953 if (attr
== NULL
|| !DW_STRING (attr
))
5956 filename
= DW_STRING (attr
);
5958 pst
= create_partial_symtab (per_cu
, filename
);
5960 /* This must be done before calling dwarf2_build_include_psymtabs. */
5961 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5963 pst
->dirname
= DW_STRING (attr
);
5965 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5967 dwarf2_find_base_address (comp_unit_die
, cu
);
5969 /* Possibly set the default values of LOWPC and HIGHPC from
5971 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
5972 &best_highpc
, cu
, pst
);
5973 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
5974 /* Store the contiguous range if it is not empty; it can be empty for
5975 CUs with no code. */
5976 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5977 gdbarch_adjust_dwarf2_addr (gdbarch
,
5978 best_lowpc
+ baseaddr
),
5979 gdbarch_adjust_dwarf2_addr (gdbarch
,
5980 best_highpc
+ baseaddr
) - 1,
5983 /* Check if comp unit has_children.
5984 If so, read the rest of the partial symbols from this comp unit.
5985 If not, there's no more debug_info for this comp unit. */
5988 struct partial_die_info
*first_die
;
5989 CORE_ADDR lowpc
, highpc
;
5991 lowpc
= ((CORE_ADDR
) -1);
5992 highpc
= ((CORE_ADDR
) 0);
5994 first_die
= load_partial_dies (reader
, info_ptr
, 1);
5996 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
5999 /* If we didn't find a lowpc, set it to highpc to avoid
6000 complaints from `maint check'. */
6001 if (lowpc
== ((CORE_ADDR
) -1))
6004 /* If the compilation unit didn't have an explicit address range,
6005 then use the information extracted from its child dies. */
6009 best_highpc
= highpc
;
6012 pst
->textlow
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
);
6013 pst
->texthigh
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
);
6015 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6016 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6017 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6018 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6019 sort_pst_symbols (objfile
, pst
);
6021 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
6024 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6025 struct dwarf2_per_cu_data
*iter
;
6027 /* Fill in 'dependencies' here; we fill in 'users' in a
6029 pst
->number_of_dependencies
= len
;
6030 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6031 len
* sizeof (struct symtab
*));
6033 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
6036 pst
->dependencies
[i
] = iter
->v
.psymtab
;
6038 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6041 /* Get the list of files included in the current compilation unit,
6042 and build a psymtab for each of them. */
6043 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
6045 if (dwarf_read_debug
)
6047 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6049 fprintf_unfiltered (gdb_stdlog
,
6050 "Psymtab for %s unit @0x%x: %s - %s"
6051 ", %d global, %d static syms\n",
6052 per_cu
->is_debug_types
? "type" : "comp",
6053 per_cu
->offset
.sect_off
,
6054 paddress (gdbarch
, pst
->textlow
),
6055 paddress (gdbarch
, pst
->texthigh
),
6056 pst
->n_global_syms
, pst
->n_static_syms
);
6060 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6061 Process compilation unit THIS_CU for a psymtab. */
6064 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
6065 int want_partial_unit
,
6066 enum language pretend_language
)
6068 struct process_psymtab_comp_unit_data info
;
6070 /* If this compilation unit was already read in, free the
6071 cached copy in order to read it in again. This is
6072 necessary because we skipped some symbols when we first
6073 read in the compilation unit (see load_partial_dies).
6074 This problem could be avoided, but the benefit is unclear. */
6075 if (this_cu
->cu
!= NULL
)
6076 free_one_cached_comp_unit (this_cu
);
6078 gdb_assert (! this_cu
->is_debug_types
);
6079 info
.want_partial_unit
= want_partial_unit
;
6080 info
.pretend_language
= pretend_language
;
6081 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
6082 process_psymtab_comp_unit_reader
,
6085 /* Age out any secondary CUs. */
6086 age_cached_comp_units ();
6089 /* Reader function for build_type_psymtabs. */
6092 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
6093 const gdb_byte
*info_ptr
,
6094 struct die_info
*type_unit_die
,
6098 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6099 struct dwarf2_cu
*cu
= reader
->cu
;
6100 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6101 struct signatured_type
*sig_type
;
6102 struct type_unit_group
*tu_group
;
6103 struct attribute
*attr
;
6104 struct partial_die_info
*first_die
;
6105 CORE_ADDR lowpc
, highpc
;
6106 struct partial_symtab
*pst
;
6108 gdb_assert (data
== NULL
);
6109 gdb_assert (per_cu
->is_debug_types
);
6110 sig_type
= (struct signatured_type
*) per_cu
;
6115 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
6116 tu_group
= get_type_unit_group (cu
, attr
);
6118 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
6120 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
6121 cu
->list_in_scope
= &file_symbols
;
6122 pst
= create_partial_symtab (per_cu
, "");
6125 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6127 lowpc
= (CORE_ADDR
) -1;
6128 highpc
= (CORE_ADDR
) 0;
6129 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
6131 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6132 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6133 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6134 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6135 sort_pst_symbols (objfile
, pst
);
6138 /* Struct used to sort TUs by their abbreviation table offset. */
6140 struct tu_abbrev_offset
6142 struct signatured_type
*sig_type
;
6143 sect_offset abbrev_offset
;
6146 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
6149 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
6151 const struct tu_abbrev_offset
* const *a
= ap
;
6152 const struct tu_abbrev_offset
* const *b
= bp
;
6153 unsigned int aoff
= (*a
)->abbrev_offset
.sect_off
;
6154 unsigned int boff
= (*b
)->abbrev_offset
.sect_off
;
6156 return (aoff
> boff
) - (aoff
< boff
);
6159 /* Efficiently read all the type units.
6160 This does the bulk of the work for build_type_psymtabs.
6162 The efficiency is because we sort TUs by the abbrev table they use and
6163 only read each abbrev table once. In one program there are 200K TUs
6164 sharing 8K abbrev tables.
6166 The main purpose of this function is to support building the
6167 dwarf2_per_objfile->type_unit_groups table.
6168 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
6169 can collapse the search space by grouping them by stmt_list.
6170 The savings can be significant, in the same program from above the 200K TUs
6171 share 8K stmt_list tables.
6173 FUNC is expected to call get_type_unit_group, which will create the
6174 struct type_unit_group if necessary and add it to
6175 dwarf2_per_objfile->type_unit_groups. */
6178 build_type_psymtabs_1 (void)
6180 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6181 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6182 struct cleanup
*cleanups
;
6183 struct abbrev_table
*abbrev_table
;
6184 sect_offset abbrev_offset
;
6185 struct tu_abbrev_offset
*sorted_by_abbrev
;
6186 struct type_unit_group
**iter
;
6189 /* It's up to the caller to not call us multiple times. */
6190 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
6192 if (dwarf2_per_objfile
->n_type_units
== 0)
6195 /* TUs typically share abbrev tables, and there can be way more TUs than
6196 abbrev tables. Sort by abbrev table to reduce the number of times we
6197 read each abbrev table in.
6198 Alternatives are to punt or to maintain a cache of abbrev tables.
6199 This is simpler and efficient enough for now.
6201 Later we group TUs by their DW_AT_stmt_list value (as this defines the
6202 symtab to use). Typically TUs with the same abbrev offset have the same
6203 stmt_list value too so in practice this should work well.
6205 The basic algorithm here is:
6207 sort TUs by abbrev table
6208 for each TU with same abbrev table:
6209 read abbrev table if first user
6210 read TU top level DIE
6211 [IWBN if DWO skeletons had DW_AT_stmt_list]
6214 if (dwarf_read_debug
)
6215 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
6217 /* Sort in a separate table to maintain the order of all_type_units
6218 for .gdb_index: TU indices directly index all_type_units. */
6219 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
6220 dwarf2_per_objfile
->n_type_units
);
6221 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6223 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
6225 sorted_by_abbrev
[i
].sig_type
= sig_type
;
6226 sorted_by_abbrev
[i
].abbrev_offset
=
6227 read_abbrev_offset (sig_type
->per_cu
.section
,
6228 sig_type
->per_cu
.offset
);
6230 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
6231 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
6232 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
6234 abbrev_offset
.sect_off
= ~(unsigned) 0;
6235 abbrev_table
= NULL
;
6236 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
6238 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6240 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
6242 /* Switch to the next abbrev table if necessary. */
6243 if (abbrev_table
== NULL
6244 || tu
->abbrev_offset
.sect_off
!= abbrev_offset
.sect_off
)
6246 if (abbrev_table
!= NULL
)
6248 abbrev_table_free (abbrev_table
);
6249 /* Reset to NULL in case abbrev_table_read_table throws
6250 an error: abbrev_table_free_cleanup will get called. */
6251 abbrev_table
= NULL
;
6253 abbrev_offset
= tu
->abbrev_offset
;
6255 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
6257 ++tu_stats
->nr_uniq_abbrev_tables
;
6260 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
6261 build_type_psymtabs_reader
, NULL
);
6264 do_cleanups (cleanups
);
6267 /* Print collected type unit statistics. */
6270 print_tu_stats (void)
6272 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6274 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
6275 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
6276 dwarf2_per_objfile
->n_type_units
);
6277 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
6278 tu_stats
->nr_uniq_abbrev_tables
);
6279 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
6280 tu_stats
->nr_symtabs
);
6281 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
6282 tu_stats
->nr_symtab_sharers
);
6283 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
6284 tu_stats
->nr_stmt_less_type_units
);
6285 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
6286 tu_stats
->nr_all_type_units_reallocs
);
6289 /* Traversal function for build_type_psymtabs. */
6292 build_type_psymtab_dependencies (void **slot
, void *info
)
6294 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6295 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
6296 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
6297 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6298 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
6299 struct signatured_type
*iter
;
6302 gdb_assert (len
> 0);
6303 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
6305 pst
->number_of_dependencies
= len
;
6306 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6307 len
* sizeof (struct psymtab
*));
6309 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
6312 gdb_assert (iter
->per_cu
.is_debug_types
);
6313 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
6314 iter
->type_unit_group
= tu_group
;
6317 VEC_free (sig_type_ptr
, tu_group
->tus
);
6322 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6323 Build partial symbol tables for the .debug_types comp-units. */
6326 build_type_psymtabs (struct objfile
*objfile
)
6328 if (! create_all_type_units (objfile
))
6331 build_type_psymtabs_1 ();
6334 /* Traversal function for process_skeletonless_type_unit.
6335 Read a TU in a DWO file and build partial symbols for it. */
6338 process_skeletonless_type_unit (void **slot
, void *info
)
6340 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
6341 struct objfile
*objfile
= info
;
6342 struct signatured_type find_entry
, *entry
;
6344 /* If this TU doesn't exist in the global table, add it and read it in. */
6346 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6348 dwarf2_per_objfile
->signatured_types
6349 = allocate_signatured_type_table (objfile
);
6352 find_entry
.signature
= dwo_unit
->signature
;
6353 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
6355 /* If we've already seen this type there's nothing to do. What's happening
6356 is we're doing our own version of comdat-folding here. */
6360 /* This does the job that create_all_type_units would have done for
6362 entry
= add_type_unit (dwo_unit
->signature
, slot
);
6363 fill_in_sig_entry_from_dwo_entry (objfile
, entry
, dwo_unit
);
6366 /* This does the job that build_type_psymtabs_1 would have done. */
6367 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0,
6368 build_type_psymtabs_reader
, NULL
);
6373 /* Traversal function for process_skeletonless_type_units. */
6376 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
6378 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
6380 if (dwo_file
->tus
!= NULL
)
6382 htab_traverse_noresize (dwo_file
->tus
,
6383 process_skeletonless_type_unit
, info
);
6389 /* Scan all TUs of DWO files, verifying we've processed them.
6390 This is needed in case a TU was emitted without its skeleton.
6391 Note: This can't be done until we know what all the DWO files are. */
6394 process_skeletonless_type_units (struct objfile
*objfile
)
6396 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
6397 if (get_dwp_file () == NULL
6398 && dwarf2_per_objfile
->dwo_files
!= NULL
)
6400 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
,
6401 process_dwo_file_for_skeletonless_type_units
,
6406 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6409 psymtabs_addrmap_cleanup (void *o
)
6411 struct objfile
*objfile
= o
;
6413 objfile
->psymtabs_addrmap
= NULL
;
6416 /* Compute the 'user' field for each psymtab in OBJFILE. */
6419 set_partial_user (struct objfile
*objfile
)
6423 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6425 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6426 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6432 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
6434 /* Set the 'user' field only if it is not already set. */
6435 if (pst
->dependencies
[j
]->user
== NULL
)
6436 pst
->dependencies
[j
]->user
= pst
;
6441 /* Build the partial symbol table by doing a quick pass through the
6442 .debug_info and .debug_abbrev sections. */
6445 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
6447 struct cleanup
*back_to
, *addrmap_cleanup
;
6448 struct obstack temp_obstack
;
6451 if (dwarf_read_debug
)
6453 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
6454 objfile_name (objfile
));
6457 dwarf2_per_objfile
->reading_partial_symbols
= 1;
6459 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
6461 /* Any cached compilation units will be linked by the per-objfile
6462 read_in_chain. Make sure to free them when we're done. */
6463 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
6465 build_type_psymtabs (objfile
);
6467 create_all_comp_units (objfile
);
6469 /* Create a temporary address map on a temporary obstack. We later
6470 copy this to the final obstack. */
6471 obstack_init (&temp_obstack
);
6472 make_cleanup_obstack_free (&temp_obstack
);
6473 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
6474 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
6476 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6478 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6480 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
6483 /* This has to wait until we read the CUs, we need the list of DWOs. */
6484 process_skeletonless_type_units (objfile
);
6486 /* Now that all TUs have been processed we can fill in the dependencies. */
6487 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
6489 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
6490 build_type_psymtab_dependencies
, NULL
);
6493 if (dwarf_read_debug
)
6496 set_partial_user (objfile
);
6498 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
6499 &objfile
->objfile_obstack
);
6500 discard_cleanups (addrmap_cleanup
);
6502 do_cleanups (back_to
);
6504 if (dwarf_read_debug
)
6505 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
6506 objfile_name (objfile
));
6509 /* die_reader_func for load_partial_comp_unit. */
6512 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
6513 const gdb_byte
*info_ptr
,
6514 struct die_info
*comp_unit_die
,
6518 struct dwarf2_cu
*cu
= reader
->cu
;
6520 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
6522 /* Check if comp unit has_children.
6523 If so, read the rest of the partial symbols from this comp unit.
6524 If not, there's no more debug_info for this comp unit. */
6526 load_partial_dies (reader
, info_ptr
, 0);
6529 /* Load the partial DIEs for a secondary CU into memory.
6530 This is also used when rereading a primary CU with load_all_dies. */
6533 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
6535 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
6536 load_partial_comp_unit_reader
, NULL
);
6540 read_comp_units_from_section (struct objfile
*objfile
,
6541 struct dwarf2_section_info
*section
,
6542 unsigned int is_dwz
,
6545 struct dwarf2_per_cu_data
***all_comp_units
)
6547 const gdb_byte
*info_ptr
;
6548 bfd
*abfd
= get_section_bfd_owner (section
);
6550 if (dwarf_read_debug
)
6551 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
6552 get_section_name (section
),
6553 get_section_file_name (section
));
6555 dwarf2_read_section (objfile
, section
);
6557 info_ptr
= section
->buffer
;
6559 while (info_ptr
< section
->buffer
+ section
->size
)
6561 unsigned int length
, initial_length_size
;
6562 struct dwarf2_per_cu_data
*this_cu
;
6565 offset
.sect_off
= info_ptr
- section
->buffer
;
6567 /* Read just enough information to find out where the next
6568 compilation unit is. */
6569 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6571 /* Save the compilation unit for later lookup. */
6572 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
6573 sizeof (struct dwarf2_per_cu_data
));
6574 memset (this_cu
, 0, sizeof (*this_cu
));
6575 this_cu
->offset
= offset
;
6576 this_cu
->length
= length
+ initial_length_size
;
6577 this_cu
->is_dwz
= is_dwz
;
6578 this_cu
->objfile
= objfile
;
6579 this_cu
->section
= section
;
6581 if (*n_comp_units
== *n_allocated
)
6584 *all_comp_units
= xrealloc (*all_comp_units
,
6586 * sizeof (struct dwarf2_per_cu_data
*));
6588 (*all_comp_units
)[*n_comp_units
] = this_cu
;
6591 info_ptr
= info_ptr
+ this_cu
->length
;
6595 /* Create a list of all compilation units in OBJFILE.
6596 This is only done for -readnow and building partial symtabs. */
6599 create_all_comp_units (struct objfile
*objfile
)
6603 struct dwarf2_per_cu_data
**all_comp_units
;
6604 struct dwz_file
*dwz
;
6608 all_comp_units
= xmalloc (n_allocated
6609 * sizeof (struct dwarf2_per_cu_data
*));
6611 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
, 0,
6612 &n_allocated
, &n_comp_units
, &all_comp_units
);
6614 dwz
= dwarf2_get_dwz_file ();
6616 read_comp_units_from_section (objfile
, &dwz
->info
, 1,
6617 &n_allocated
, &n_comp_units
,
6620 dwarf2_per_objfile
->all_comp_units
6621 = obstack_alloc (&objfile
->objfile_obstack
,
6622 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6623 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
6624 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6625 xfree (all_comp_units
);
6626 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
6629 /* Process all loaded DIEs for compilation unit CU, starting at
6630 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
6631 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6632 DW_AT_ranges). See the comments of add_partial_subprogram on how
6633 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
6636 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
6637 CORE_ADDR
*highpc
, int set_addrmap
,
6638 struct dwarf2_cu
*cu
)
6640 struct partial_die_info
*pdi
;
6642 /* Now, march along the PDI's, descending into ones which have
6643 interesting children but skipping the children of the other ones,
6644 until we reach the end of the compilation unit. */
6650 fixup_partial_die (pdi
, cu
);
6652 /* Anonymous namespaces or modules have no name but have interesting
6653 children, so we need to look at them. Ditto for anonymous
6656 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
6657 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
6658 || pdi
->tag
== DW_TAG_imported_unit
)
6662 case DW_TAG_subprogram
:
6663 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6665 case DW_TAG_constant
:
6666 case DW_TAG_variable
:
6667 case DW_TAG_typedef
:
6668 case DW_TAG_union_type
:
6669 if (!pdi
->is_declaration
)
6671 add_partial_symbol (pdi
, cu
);
6674 case DW_TAG_class_type
:
6675 case DW_TAG_interface_type
:
6676 case DW_TAG_structure_type
:
6677 if (!pdi
->is_declaration
)
6679 add_partial_symbol (pdi
, cu
);
6682 case DW_TAG_enumeration_type
:
6683 if (!pdi
->is_declaration
)
6684 add_partial_enumeration (pdi
, cu
);
6686 case DW_TAG_base_type
:
6687 case DW_TAG_subrange_type
:
6688 /* File scope base type definitions are added to the partial
6690 add_partial_symbol (pdi
, cu
);
6692 case DW_TAG_namespace
:
6693 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6696 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6698 case DW_TAG_imported_unit
:
6700 struct dwarf2_per_cu_data
*per_cu
;
6702 /* For now we don't handle imported units in type units. */
6703 if (cu
->per_cu
->is_debug_types
)
6705 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6706 " supported in type units [in module %s]"),
6707 objfile_name (cu
->objfile
));
6710 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
6714 /* Go read the partial unit, if needed. */
6715 if (per_cu
->v
.psymtab
== NULL
)
6716 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
6718 VEC_safe_push (dwarf2_per_cu_ptr
,
6719 cu
->per_cu
->imported_symtabs
, per_cu
);
6722 case DW_TAG_imported_declaration
:
6723 add_partial_symbol (pdi
, cu
);
6730 /* If the die has a sibling, skip to the sibling. */
6732 pdi
= pdi
->die_sibling
;
6736 /* Functions used to compute the fully scoped name of a partial DIE.
6738 Normally, this is simple. For C++, the parent DIE's fully scoped
6739 name is concatenated with "::" and the partial DIE's name. For
6740 Java, the same thing occurs except that "." is used instead of "::".
6741 Enumerators are an exception; they use the scope of their parent
6742 enumeration type, i.e. the name of the enumeration type is not
6743 prepended to the enumerator.
6745 There are two complexities. One is DW_AT_specification; in this
6746 case "parent" means the parent of the target of the specification,
6747 instead of the direct parent of the DIE. The other is compilers
6748 which do not emit DW_TAG_namespace; in this case we try to guess
6749 the fully qualified name of structure types from their members'
6750 linkage names. This must be done using the DIE's children rather
6751 than the children of any DW_AT_specification target. We only need
6752 to do this for structures at the top level, i.e. if the target of
6753 any DW_AT_specification (if any; otherwise the DIE itself) does not
6756 /* Compute the scope prefix associated with PDI's parent, in
6757 compilation unit CU. The result will be allocated on CU's
6758 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6759 field. NULL is returned if no prefix is necessary. */
6761 partial_die_parent_scope (struct partial_die_info
*pdi
,
6762 struct dwarf2_cu
*cu
)
6764 const char *grandparent_scope
;
6765 struct partial_die_info
*parent
, *real_pdi
;
6767 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6768 then this means the parent of the specification DIE. */
6771 while (real_pdi
->has_specification
)
6772 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
6773 real_pdi
->spec_is_dwz
, cu
);
6775 parent
= real_pdi
->die_parent
;
6779 if (parent
->scope_set
)
6780 return parent
->scope
;
6782 fixup_partial_die (parent
, cu
);
6784 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
6786 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6787 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6788 Work around this problem here. */
6789 if (cu
->language
== language_cplus
6790 && parent
->tag
== DW_TAG_namespace
6791 && strcmp (parent
->name
, "::") == 0
6792 && grandparent_scope
== NULL
)
6794 parent
->scope
= NULL
;
6795 parent
->scope_set
= 1;
6799 if (pdi
->tag
== DW_TAG_enumerator
)
6800 /* Enumerators should not get the name of the enumeration as a prefix. */
6801 parent
->scope
= grandparent_scope
;
6802 else if (parent
->tag
== DW_TAG_namespace
6803 || parent
->tag
== DW_TAG_module
6804 || parent
->tag
== DW_TAG_structure_type
6805 || parent
->tag
== DW_TAG_class_type
6806 || parent
->tag
== DW_TAG_interface_type
6807 || parent
->tag
== DW_TAG_union_type
6808 || parent
->tag
== DW_TAG_enumeration_type
)
6810 if (grandparent_scope
== NULL
)
6811 parent
->scope
= parent
->name
;
6813 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
6815 parent
->name
, 0, cu
);
6819 /* FIXME drow/2004-04-01: What should we be doing with
6820 function-local names? For partial symbols, we should probably be
6822 complaint (&symfile_complaints
,
6823 _("unhandled containing DIE tag %d for DIE at %d"),
6824 parent
->tag
, pdi
->offset
.sect_off
);
6825 parent
->scope
= grandparent_scope
;
6828 parent
->scope_set
= 1;
6829 return parent
->scope
;
6832 /* Return the fully scoped name associated with PDI, from compilation unit
6833 CU. The result will be allocated with malloc. */
6836 partial_die_full_name (struct partial_die_info
*pdi
,
6837 struct dwarf2_cu
*cu
)
6839 const char *parent_scope
;
6841 /* If this is a template instantiation, we can not work out the
6842 template arguments from partial DIEs. So, unfortunately, we have
6843 to go through the full DIEs. At least any work we do building
6844 types here will be reused if full symbols are loaded later. */
6845 if (pdi
->has_template_arguments
)
6847 fixup_partial_die (pdi
, cu
);
6849 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
6851 struct die_info
*die
;
6852 struct attribute attr
;
6853 struct dwarf2_cu
*ref_cu
= cu
;
6855 /* DW_FORM_ref_addr is using section offset. */
6857 attr
.form
= DW_FORM_ref_addr
;
6858 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
6859 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
6861 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
6865 parent_scope
= partial_die_parent_scope (pdi
, cu
);
6866 if (parent_scope
== NULL
)
6869 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
6873 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
6875 struct objfile
*objfile
= cu
->objfile
;
6876 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6878 const char *actual_name
= NULL
;
6880 char *built_actual_name
;
6882 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6884 built_actual_name
= partial_die_full_name (pdi
, cu
);
6885 if (built_actual_name
!= NULL
)
6886 actual_name
= built_actual_name
;
6888 if (actual_name
== NULL
)
6889 actual_name
= pdi
->name
;
6893 case DW_TAG_subprogram
:
6894 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
);
6895 if (pdi
->is_external
|| cu
->language
== language_ada
)
6897 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6898 of the global scope. But in Ada, we want to be able to access
6899 nested procedures globally. So all Ada subprograms are stored
6900 in the global scope. */
6901 /* prim_record_minimal_symbol (actual_name, addr, mst_text,
6903 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6904 built_actual_name
!= NULL
,
6905 VAR_DOMAIN
, LOC_BLOCK
,
6906 &objfile
->global_psymbols
,
6907 0, addr
, cu
->language
, objfile
);
6911 /* prim_record_minimal_symbol (actual_name, addr, mst_file_text,
6913 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6914 built_actual_name
!= NULL
,
6915 VAR_DOMAIN
, LOC_BLOCK
,
6916 &objfile
->static_psymbols
,
6917 0, addr
, cu
->language
, objfile
);
6920 case DW_TAG_constant
:
6922 struct psymbol_allocation_list
*list
;
6924 if (pdi
->is_external
)
6925 list
= &objfile
->global_psymbols
;
6927 list
= &objfile
->static_psymbols
;
6928 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6929 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
6930 list
, 0, 0, cu
->language
, objfile
);
6933 case DW_TAG_variable
:
6935 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
6939 && !dwarf2_per_objfile
->has_section_at_zero
)
6941 /* A global or static variable may also have been stripped
6942 out by the linker if unused, in which case its address
6943 will be nullified; do not add such variables into partial
6944 symbol table then. */
6946 else if (pdi
->is_external
)
6949 Don't enter into the minimal symbol tables as there is
6950 a minimal symbol table entry from the ELF symbols already.
6951 Enter into partial symbol table if it has a location
6952 descriptor or a type.
6953 If the location descriptor is missing, new_symbol will create
6954 a LOC_UNRESOLVED symbol, the address of the variable will then
6955 be determined from the minimal symbol table whenever the variable
6957 The address for the partial symbol table entry is not
6958 used by GDB, but it comes in handy for debugging partial symbol
6961 if (pdi
->d
.locdesc
|| pdi
->has_type
)
6962 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6963 built_actual_name
!= NULL
,
6964 VAR_DOMAIN
, LOC_STATIC
,
6965 &objfile
->global_psymbols
,
6967 cu
->language
, objfile
);
6971 int has_loc
= pdi
->d
.locdesc
!= NULL
;
6973 /* Static Variable. Skip symbols whose value we cannot know (those
6974 without location descriptors or constant values). */
6975 if (!has_loc
&& !pdi
->has_const_value
)
6977 xfree (built_actual_name
);
6981 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6982 mst_file_data, objfile); */
6983 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6984 built_actual_name
!= NULL
,
6985 VAR_DOMAIN
, LOC_STATIC
,
6986 &objfile
->static_psymbols
,
6988 has_loc
? addr
+ baseaddr
: (CORE_ADDR
) 0,
6989 cu
->language
, objfile
);
6992 case DW_TAG_typedef
:
6993 case DW_TAG_base_type
:
6994 case DW_TAG_subrange_type
:
6995 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6996 built_actual_name
!= NULL
,
6997 VAR_DOMAIN
, LOC_TYPEDEF
,
6998 &objfile
->static_psymbols
,
6999 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7001 case DW_TAG_imported_declaration
:
7002 case DW_TAG_namespace
:
7003 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7004 built_actual_name
!= NULL
,
7005 VAR_DOMAIN
, LOC_TYPEDEF
,
7006 &objfile
->global_psymbols
,
7007 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7010 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7011 built_actual_name
!= NULL
,
7012 MODULE_DOMAIN
, LOC_TYPEDEF
,
7013 &objfile
->global_psymbols
,
7014 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7016 case DW_TAG_class_type
:
7017 case DW_TAG_interface_type
:
7018 case DW_TAG_structure_type
:
7019 case DW_TAG_union_type
:
7020 case DW_TAG_enumeration_type
:
7021 /* Skip external references. The DWARF standard says in the section
7022 about "Structure, Union, and Class Type Entries": "An incomplete
7023 structure, union or class type is represented by a structure,
7024 union or class entry that does not have a byte size attribute
7025 and that has a DW_AT_declaration attribute." */
7026 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
7028 xfree (built_actual_name
);
7032 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
7033 static vs. global. */
7034 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7035 built_actual_name
!= NULL
,
7036 STRUCT_DOMAIN
, LOC_TYPEDEF
,
7037 (cu
->language
== language_cplus
7038 || cu
->language
== language_java
)
7039 ? &objfile
->global_psymbols
7040 : &objfile
->static_psymbols
,
7041 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7044 case DW_TAG_enumerator
:
7045 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7046 built_actual_name
!= NULL
,
7047 VAR_DOMAIN
, LOC_CONST
,
7048 (cu
->language
== language_cplus
7049 || cu
->language
== language_java
)
7050 ? &objfile
->global_psymbols
7051 : &objfile
->static_psymbols
,
7052 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7058 xfree (built_actual_name
);
7061 /* Read a partial die corresponding to a namespace; also, add a symbol
7062 corresponding to that namespace to the symbol table. NAMESPACE is
7063 the name of the enclosing namespace. */
7066 add_partial_namespace (struct partial_die_info
*pdi
,
7067 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7068 int set_addrmap
, struct dwarf2_cu
*cu
)
7070 /* Add a symbol for the namespace. */
7072 add_partial_symbol (pdi
, cu
);
7074 /* Now scan partial symbols in that namespace. */
7076 if (pdi
->has_children
)
7077 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7080 /* Read a partial die corresponding to a Fortran module. */
7083 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
7084 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
7086 /* Add a symbol for the namespace. */
7088 add_partial_symbol (pdi
, cu
);
7090 /* Now scan partial symbols in that module. */
7092 if (pdi
->has_children
)
7093 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7096 /* Read a partial die corresponding to a subprogram and create a partial
7097 symbol for that subprogram. When the CU language allows it, this
7098 routine also defines a partial symbol for each nested subprogram
7099 that this subprogram contains. If SET_ADDRMAP is true, record the
7100 covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
7101 and highest PC values found in PDI.
7103 PDI may also be a lexical block, in which case we simply search
7104 recursively for subprograms defined inside that lexical block.
7105 Again, this is only performed when the CU language allows this
7106 type of definitions. */
7109 add_partial_subprogram (struct partial_die_info
*pdi
,
7110 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7111 int set_addrmap
, struct dwarf2_cu
*cu
)
7113 if (pdi
->tag
== DW_TAG_subprogram
)
7115 if (pdi
->has_pc_info
)
7117 if (pdi
->lowpc
< *lowpc
)
7118 *lowpc
= pdi
->lowpc
;
7119 if (pdi
->highpc
> *highpc
)
7120 *highpc
= pdi
->highpc
;
7123 struct objfile
*objfile
= cu
->objfile
;
7124 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7129 baseaddr
= ANOFFSET (objfile
->section_offsets
,
7130 SECT_OFF_TEXT (objfile
));
7131 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7132 pdi
->lowpc
+ baseaddr
);
7133 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7134 pdi
->highpc
+ baseaddr
);
7135 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
7136 cu
->per_cu
->v
.psymtab
);
7140 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
7142 if (!pdi
->is_declaration
)
7143 /* Ignore subprogram DIEs that do not have a name, they are
7144 illegal. Do not emit a complaint at this point, we will
7145 do so when we convert this psymtab into a symtab. */
7147 add_partial_symbol (pdi
, cu
);
7151 if (! pdi
->has_children
)
7154 if (cu
->language
== language_ada
)
7156 pdi
= pdi
->die_child
;
7159 fixup_partial_die (pdi
, cu
);
7160 if (pdi
->tag
== DW_TAG_subprogram
7161 || pdi
->tag
== DW_TAG_lexical_block
)
7162 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7163 pdi
= pdi
->die_sibling
;
7168 /* Read a partial die corresponding to an enumeration type. */
7171 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
7172 struct dwarf2_cu
*cu
)
7174 struct partial_die_info
*pdi
;
7176 if (enum_pdi
->name
!= NULL
)
7177 add_partial_symbol (enum_pdi
, cu
);
7179 pdi
= enum_pdi
->die_child
;
7182 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
7183 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
7185 add_partial_symbol (pdi
, cu
);
7186 pdi
= pdi
->die_sibling
;
7190 /* Return the initial uleb128 in the die at INFO_PTR. */
7193 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
7195 unsigned int bytes_read
;
7197 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7200 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7201 Return the corresponding abbrev, or NULL if the number is zero (indicating
7202 an empty DIE). In either case *BYTES_READ will be set to the length of
7203 the initial number. */
7205 static struct abbrev_info
*
7206 peek_die_abbrev (const gdb_byte
*info_ptr
, unsigned int *bytes_read
,
7207 struct dwarf2_cu
*cu
)
7209 bfd
*abfd
= cu
->objfile
->obfd
;
7210 unsigned int abbrev_number
;
7211 struct abbrev_info
*abbrev
;
7213 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
7215 if (abbrev_number
== 0)
7218 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
7221 error (_("Dwarf Error: Could not find abbrev number %d in %s"
7222 " at offset 0x%x [in module %s]"),
7223 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
7224 cu
->header
.offset
.sect_off
, bfd_get_filename (abfd
));
7230 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7231 Returns a pointer to the end of a series of DIEs, terminated by an empty
7232 DIE. Any children of the skipped DIEs will also be skipped. */
7234 static const gdb_byte
*
7235 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
7237 struct dwarf2_cu
*cu
= reader
->cu
;
7238 struct abbrev_info
*abbrev
;
7239 unsigned int bytes_read
;
7243 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
7245 return info_ptr
+ bytes_read
;
7247 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
7251 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7252 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7253 abbrev corresponding to that skipped uleb128 should be passed in
7254 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7257 static const gdb_byte
*
7258 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
7259 struct abbrev_info
*abbrev
)
7261 unsigned int bytes_read
;
7262 struct attribute attr
;
7263 bfd
*abfd
= reader
->abfd
;
7264 struct dwarf2_cu
*cu
= reader
->cu
;
7265 const gdb_byte
*buffer
= reader
->buffer
;
7266 const gdb_byte
*buffer_end
= reader
->buffer_end
;
7267 const gdb_byte
*start_info_ptr
= info_ptr
;
7268 unsigned int form
, i
;
7270 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
7272 /* The only abbrev we care about is DW_AT_sibling. */
7273 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
7275 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
7276 if (attr
.form
== DW_FORM_ref_addr
)
7277 complaint (&symfile_complaints
,
7278 _("ignoring absolute DW_AT_sibling"));
7281 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
7282 const gdb_byte
*sibling_ptr
= buffer
+ off
;
7284 if (sibling_ptr
< info_ptr
)
7285 complaint (&symfile_complaints
,
7286 _("DW_AT_sibling points backwards"));
7287 else if (sibling_ptr
> reader
->buffer_end
)
7288 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
7294 /* If it isn't DW_AT_sibling, skip this attribute. */
7295 form
= abbrev
->attrs
[i
].form
;
7299 case DW_FORM_ref_addr
:
7300 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7301 and later it is offset sized. */
7302 if (cu
->header
.version
== 2)
7303 info_ptr
+= cu
->header
.addr_size
;
7305 info_ptr
+= cu
->header
.offset_size
;
7307 case DW_FORM_GNU_ref_alt
:
7308 info_ptr
+= cu
->header
.offset_size
;
7311 info_ptr
+= cu
->header
.addr_size
;
7318 case DW_FORM_flag_present
:
7330 case DW_FORM_ref_sig8
:
7333 case DW_FORM_string
:
7334 read_direct_string (abfd
, info_ptr
, &bytes_read
);
7335 info_ptr
+= bytes_read
;
7337 case DW_FORM_sec_offset
:
7339 case DW_FORM_GNU_strp_alt
:
7340 info_ptr
+= cu
->header
.offset_size
;
7342 case DW_FORM_exprloc
:
7344 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7345 info_ptr
+= bytes_read
;
7347 case DW_FORM_block1
:
7348 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
7350 case DW_FORM_block2
:
7351 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
7353 case DW_FORM_block4
:
7354 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
7358 case DW_FORM_ref_udata
:
7359 case DW_FORM_GNU_addr_index
:
7360 case DW_FORM_GNU_str_index
:
7361 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
7363 case DW_FORM_indirect
:
7364 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7365 info_ptr
+= bytes_read
;
7366 /* We need to continue parsing from here, so just go back to
7368 goto skip_attribute
;
7371 error (_("Dwarf Error: Cannot handle %s "
7372 "in DWARF reader [in module %s]"),
7373 dwarf_form_name (form
),
7374 bfd_get_filename (abfd
));
7378 if (abbrev
->has_children
)
7379 return skip_children (reader
, info_ptr
);
7384 /* Locate ORIG_PDI's sibling.
7385 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7387 static const gdb_byte
*
7388 locate_pdi_sibling (const struct die_reader_specs
*reader
,
7389 struct partial_die_info
*orig_pdi
,
7390 const gdb_byte
*info_ptr
)
7392 /* Do we know the sibling already? */
7394 if (orig_pdi
->sibling
)
7395 return orig_pdi
->sibling
;
7397 /* Are there any children to deal with? */
7399 if (!orig_pdi
->has_children
)
7402 /* Skip the children the long way. */
7404 return skip_children (reader
, info_ptr
);
7407 /* Expand this partial symbol table into a full symbol table. SELF is
7411 dwarf2_read_symtab (struct partial_symtab
*self
,
7412 struct objfile
*objfile
)
7416 warning (_("bug: psymtab for %s is already read in."),
7423 printf_filtered (_("Reading in symbols for %s..."),
7425 gdb_flush (gdb_stdout
);
7428 /* Restore our global data. */
7429 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
7431 /* If this psymtab is constructed from a debug-only objfile, the
7432 has_section_at_zero flag will not necessarily be correct. We
7433 can get the correct value for this flag by looking at the data
7434 associated with the (presumably stripped) associated objfile. */
7435 if (objfile
->separate_debug_objfile_backlink
)
7437 struct dwarf2_per_objfile
*dpo_backlink
7438 = objfile_data (objfile
->separate_debug_objfile_backlink
,
7439 dwarf2_objfile_data_key
);
7441 dwarf2_per_objfile
->has_section_at_zero
7442 = dpo_backlink
->has_section_at_zero
;
7445 dwarf2_per_objfile
->reading_partial_symbols
= 0;
7447 psymtab_to_symtab_1 (self
);
7449 /* Finish up the debug error message. */
7451 printf_filtered (_("done.\n"));
7454 process_cu_includes ();
7457 /* Reading in full CUs. */
7459 /* Add PER_CU to the queue. */
7462 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
7463 enum language pretend_language
)
7465 struct dwarf2_queue_item
*item
;
7468 item
= xmalloc (sizeof (*item
));
7469 item
->per_cu
= per_cu
;
7470 item
->pretend_language
= pretend_language
;
7473 if (dwarf2_queue
== NULL
)
7474 dwarf2_queue
= item
;
7476 dwarf2_queue_tail
->next
= item
;
7478 dwarf2_queue_tail
= item
;
7481 /* If PER_CU is not yet queued, add it to the queue.
7482 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7484 The result is non-zero if PER_CU was queued, otherwise the result is zero
7485 meaning either PER_CU is already queued or it is already loaded.
7487 N.B. There is an invariant here that if a CU is queued then it is loaded.
7488 The caller is required to load PER_CU if we return non-zero. */
7491 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
7492 struct dwarf2_per_cu_data
*per_cu
,
7493 enum language pretend_language
)
7495 /* We may arrive here during partial symbol reading, if we need full
7496 DIEs to process an unusual case (e.g. template arguments). Do
7497 not queue PER_CU, just tell our caller to load its DIEs. */
7498 if (dwarf2_per_objfile
->reading_partial_symbols
)
7500 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
7505 /* Mark the dependence relation so that we don't flush PER_CU
7507 if (dependent_cu
!= NULL
)
7508 dwarf2_add_dependence (dependent_cu
, per_cu
);
7510 /* If it's already on the queue, we have nothing to do. */
7514 /* If the compilation unit is already loaded, just mark it as
7516 if (per_cu
->cu
!= NULL
)
7518 per_cu
->cu
->last_used
= 0;
7522 /* Add it to the queue. */
7523 queue_comp_unit (per_cu
, pretend_language
);
7528 /* Process the queue. */
7531 process_queue (void)
7533 struct dwarf2_queue_item
*item
, *next_item
;
7535 if (dwarf_read_debug
)
7537 fprintf_unfiltered (gdb_stdlog
,
7538 "Expanding one or more symtabs of objfile %s ...\n",
7539 objfile_name (dwarf2_per_objfile
->objfile
));
7542 /* The queue starts out with one item, but following a DIE reference
7543 may load a new CU, adding it to the end of the queue. */
7544 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
7546 if (dwarf2_per_objfile
->using_index
7547 ? !item
->per_cu
->v
.quick
->compunit_symtab
7548 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
7550 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
7551 unsigned int debug_print_threshold
;
7554 if (per_cu
->is_debug_types
)
7556 struct signatured_type
*sig_type
=
7557 (struct signatured_type
*) per_cu
;
7559 sprintf (buf
, "TU %s at offset 0x%x",
7560 hex_string (sig_type
->signature
),
7561 per_cu
->offset
.sect_off
);
7562 /* There can be 100s of TUs.
7563 Only print them in verbose mode. */
7564 debug_print_threshold
= 2;
7568 sprintf (buf
, "CU at offset 0x%x", per_cu
->offset
.sect_off
);
7569 debug_print_threshold
= 1;
7572 if (dwarf_read_debug
>= debug_print_threshold
)
7573 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
7575 if (per_cu
->is_debug_types
)
7576 process_full_type_unit (per_cu
, item
->pretend_language
);
7578 process_full_comp_unit (per_cu
, item
->pretend_language
);
7580 if (dwarf_read_debug
>= debug_print_threshold
)
7581 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
7584 item
->per_cu
->queued
= 0;
7585 next_item
= item
->next
;
7589 dwarf2_queue_tail
= NULL
;
7591 if (dwarf_read_debug
)
7593 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
7594 objfile_name (dwarf2_per_objfile
->objfile
));
7598 /* Free all allocated queue entries. This function only releases anything if
7599 an error was thrown; if the queue was processed then it would have been
7600 freed as we went along. */
7603 dwarf2_release_queue (void *dummy
)
7605 struct dwarf2_queue_item
*item
, *last
;
7607 item
= dwarf2_queue
;
7610 /* Anything still marked queued is likely to be in an
7611 inconsistent state, so discard it. */
7612 if (item
->per_cu
->queued
)
7614 if (item
->per_cu
->cu
!= NULL
)
7615 free_one_cached_comp_unit (item
->per_cu
);
7616 item
->per_cu
->queued
= 0;
7624 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
7627 /* Read in full symbols for PST, and anything it depends on. */
7630 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
7632 struct dwarf2_per_cu_data
*per_cu
;
7638 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
7639 if (!pst
->dependencies
[i
]->readin
7640 && pst
->dependencies
[i
]->user
== NULL
)
7642 /* Inform about additional files that need to be read in. */
7645 /* FIXME: i18n: Need to make this a single string. */
7646 fputs_filtered (" ", gdb_stdout
);
7648 fputs_filtered ("and ", gdb_stdout
);
7650 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
7651 wrap_here (""); /* Flush output. */
7652 gdb_flush (gdb_stdout
);
7654 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
7657 per_cu
= pst
->read_symtab_private
;
7661 /* It's an include file, no symbols to read for it.
7662 Everything is in the parent symtab. */
7667 dw2_do_instantiate_symtab (per_cu
);
7670 /* Trivial hash function for die_info: the hash value of a DIE
7671 is its offset in .debug_info for this objfile. */
7674 die_hash (const void *item
)
7676 const struct die_info
*die
= item
;
7678 return die
->offset
.sect_off
;
7681 /* Trivial comparison function for die_info structures: two DIEs
7682 are equal if they have the same offset. */
7685 die_eq (const void *item_lhs
, const void *item_rhs
)
7687 const struct die_info
*die_lhs
= item_lhs
;
7688 const struct die_info
*die_rhs
= item_rhs
;
7690 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
7693 /* die_reader_func for load_full_comp_unit.
7694 This is identical to read_signatured_type_reader,
7695 but is kept separate for now. */
7698 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
7699 const gdb_byte
*info_ptr
,
7700 struct die_info
*comp_unit_die
,
7704 struct dwarf2_cu
*cu
= reader
->cu
;
7705 enum language
*language_ptr
= data
;
7707 gdb_assert (cu
->die_hash
== NULL
);
7709 htab_create_alloc_ex (cu
->header
.length
/ 12,
7713 &cu
->comp_unit_obstack
,
7714 hashtab_obstack_allocate
,
7715 dummy_obstack_deallocate
);
7718 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
7719 &info_ptr
, comp_unit_die
);
7720 cu
->dies
= comp_unit_die
;
7721 /* comp_unit_die is not stored in die_hash, no need. */
7723 /* We try not to read any attributes in this function, because not
7724 all CUs needed for references have been loaded yet, and symbol
7725 table processing isn't initialized. But we have to set the CU language,
7726 or we won't be able to build types correctly.
7727 Similarly, if we do not read the producer, we can not apply
7728 producer-specific interpretation. */
7729 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
7732 /* Load the DIEs associated with PER_CU into memory. */
7735 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7736 enum language pretend_language
)
7738 gdb_assert (! this_cu
->is_debug_types
);
7740 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
7741 load_full_comp_unit_reader
, &pretend_language
);
7744 /* Add a DIE to the delayed physname list. */
7747 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
7748 const char *name
, struct die_info
*die
,
7749 struct dwarf2_cu
*cu
)
7751 struct delayed_method_info mi
;
7753 mi
.fnfield_index
= fnfield_index
;
7757 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
7760 /* A cleanup for freeing the delayed method list. */
7763 free_delayed_list (void *ptr
)
7765 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
7766 if (cu
->method_list
!= NULL
)
7768 VEC_free (delayed_method_info
, cu
->method_list
);
7769 cu
->method_list
= NULL
;
7773 /* Compute the physnames of any methods on the CU's method list.
7775 The computation of method physnames is delayed in order to avoid the
7776 (bad) condition that one of the method's formal parameters is of an as yet
7780 compute_delayed_physnames (struct dwarf2_cu
*cu
)
7783 struct delayed_method_info
*mi
;
7784 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
7786 const char *physname
;
7787 struct fn_fieldlist
*fn_flp
7788 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
7789 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
7790 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
->index
)
7791 = physname
? physname
: "";
7795 /* Go objects should be embedded in a DW_TAG_module DIE,
7796 and it's not clear if/how imported objects will appear.
7797 To keep Go support simple until that's worked out,
7798 go back through what we've read and create something usable.
7799 We could do this while processing each DIE, and feels kinda cleaner,
7800 but that way is more invasive.
7801 This is to, for example, allow the user to type "p var" or "b main"
7802 without having to specify the package name, and allow lookups
7803 of module.object to work in contexts that use the expression
7807 fixup_go_packaging (struct dwarf2_cu
*cu
)
7809 char *package_name
= NULL
;
7810 struct pending
*list
;
7813 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
7815 for (i
= 0; i
< list
->nsyms
; ++i
)
7817 struct symbol
*sym
= list
->symbol
[i
];
7819 if (SYMBOL_LANGUAGE (sym
) == language_go
7820 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
7822 char *this_package_name
= go_symbol_package_name (sym
);
7824 if (this_package_name
== NULL
)
7826 if (package_name
== NULL
)
7827 package_name
= this_package_name
;
7830 if (strcmp (package_name
, this_package_name
) != 0)
7831 complaint (&symfile_complaints
,
7832 _("Symtab %s has objects from two different Go packages: %s and %s"),
7833 (symbol_symtab (sym
) != NULL
7834 ? symtab_to_filename_for_display
7835 (symbol_symtab (sym
))
7836 : objfile_name (cu
->objfile
)),
7837 this_package_name
, package_name
);
7838 xfree (this_package_name
);
7844 if (package_name
!= NULL
)
7846 struct objfile
*objfile
= cu
->objfile
;
7847 const char *saved_package_name
7848 = obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
7850 strlen (package_name
));
7851 struct type
*type
= init_type (TYPE_CODE_MODULE
, 0, 0,
7852 saved_package_name
, objfile
);
7855 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7857 sym
= allocate_symbol (objfile
);
7858 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
7859 SYMBOL_SET_NAMES (sym
, saved_package_name
,
7860 strlen (saved_package_name
), 0, objfile
);
7861 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7862 e.g., "main" finds the "main" module and not C's main(). */
7863 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7864 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
7865 SYMBOL_TYPE (sym
) = type
;
7867 add_symbol_to_list (sym
, &global_symbols
);
7869 xfree (package_name
);
7873 /* Return the symtab for PER_CU. This works properly regardless of
7874 whether we're using the index or psymtabs. */
7876 static struct compunit_symtab
*
7877 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
7879 return (dwarf2_per_objfile
->using_index
7880 ? per_cu
->v
.quick
->compunit_symtab
7881 : per_cu
->v
.psymtab
->compunit_symtab
);
7884 /* A helper function for computing the list of all symbol tables
7885 included by PER_CU. */
7888 recursively_compute_inclusions (VEC (compunit_symtab_ptr
) **result
,
7889 htab_t all_children
, htab_t all_type_symtabs
,
7890 struct dwarf2_per_cu_data
*per_cu
,
7891 struct compunit_symtab
*immediate_parent
)
7895 struct compunit_symtab
*cust
;
7896 struct dwarf2_per_cu_data
*iter
;
7898 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
7901 /* This inclusion and its children have been processed. */
7906 /* Only add a CU if it has a symbol table. */
7907 cust
= get_compunit_symtab (per_cu
);
7910 /* If this is a type unit only add its symbol table if we haven't
7911 seen it yet (type unit per_cu's can share symtabs). */
7912 if (per_cu
->is_debug_types
)
7914 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
7918 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7919 if (cust
->user
== NULL
)
7920 cust
->user
= immediate_parent
;
7925 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7926 if (cust
->user
== NULL
)
7927 cust
->user
= immediate_parent
;
7932 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
7935 recursively_compute_inclusions (result
, all_children
,
7936 all_type_symtabs
, iter
, cust
);
7940 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
7944 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
7946 gdb_assert (! per_cu
->is_debug_types
);
7948 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
7951 struct dwarf2_per_cu_data
*per_cu_iter
;
7952 struct compunit_symtab
*compunit_symtab_iter
;
7953 VEC (compunit_symtab_ptr
) *result_symtabs
= NULL
;
7954 htab_t all_children
, all_type_symtabs
;
7955 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
7957 /* If we don't have a symtab, we can just skip this case. */
7961 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7962 NULL
, xcalloc
, xfree
);
7963 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7964 NULL
, xcalloc
, xfree
);
7967 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
7971 recursively_compute_inclusions (&result_symtabs
, all_children
,
7972 all_type_symtabs
, per_cu_iter
,
7976 /* Now we have a transitive closure of all the included symtabs. */
7977 len
= VEC_length (compunit_symtab_ptr
, result_symtabs
);
7979 = obstack_alloc (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
7980 (len
+ 1) * sizeof (struct symtab
*));
7982 VEC_iterate (compunit_symtab_ptr
, result_symtabs
, ix
,
7983 compunit_symtab_iter
);
7985 cust
->includes
[ix
] = compunit_symtab_iter
;
7986 cust
->includes
[len
] = NULL
;
7988 VEC_free (compunit_symtab_ptr
, result_symtabs
);
7989 htab_delete (all_children
);
7990 htab_delete (all_type_symtabs
);
7994 /* Compute the 'includes' field for the symtabs of all the CUs we just
7998 process_cu_includes (void)
8001 struct dwarf2_per_cu_data
*iter
;
8004 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
8008 if (! iter
->is_debug_types
)
8009 compute_compunit_symtab_includes (iter
);
8012 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
8015 /* Generate full symbol information for PER_CU, whose DIEs have
8016 already been loaded into memory. */
8019 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
8020 enum language pretend_language
)
8022 struct dwarf2_cu
*cu
= per_cu
->cu
;
8023 struct objfile
*objfile
= per_cu
->objfile
;
8024 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8025 CORE_ADDR lowpc
, highpc
;
8026 struct compunit_symtab
*cust
;
8027 struct cleanup
*back_to
, *delayed_list_cleanup
;
8029 struct block
*static_block
;
8032 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8035 back_to
= make_cleanup (really_free_pendings
, NULL
);
8036 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8038 cu
->list_in_scope
= &file_symbols
;
8040 cu
->language
= pretend_language
;
8041 cu
->language_defn
= language_def (cu
->language
);
8043 /* Do line number decoding in read_file_scope () */
8044 process_die (cu
->dies
, cu
);
8046 /* For now fudge the Go package. */
8047 if (cu
->language
== language_go
)
8048 fixup_go_packaging (cu
);
8050 /* Now that we have processed all the DIEs in the CU, all the types
8051 should be complete, and it should now be safe to compute all of the
8053 compute_delayed_physnames (cu
);
8054 do_cleanups (delayed_list_cleanup
);
8056 /* Some compilers don't define a DW_AT_high_pc attribute for the
8057 compilation unit. If the DW_AT_high_pc is missing, synthesize
8058 it, by scanning the DIE's below the compilation unit. */
8059 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
8061 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
8062 static_block
= end_symtab_get_static_block (addr
, 0, 1);
8064 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
8065 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
8066 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
8067 addrmap to help ensure it has an accurate map of pc values belonging to
8069 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
8071 cust
= end_symtab_from_static_block (static_block
,
8072 SECT_OFF_TEXT (objfile
), 0);
8076 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
8078 /* Set symtab language to language from DW_AT_language. If the
8079 compilation is from a C file generated by language preprocessors, do
8080 not set the language if it was already deduced by start_subfile. */
8081 if (!(cu
->language
== language_c
8082 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
8083 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8085 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
8086 produce DW_AT_location with location lists but it can be possibly
8087 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
8088 there were bugs in prologue debug info, fixed later in GCC-4.5
8089 by "unwind info for epilogues" patch (which is not directly related).
8091 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
8092 needed, it would be wrong due to missing DW_AT_producer there.
8094 Still one can confuse GDB by using non-standard GCC compilation
8095 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
8097 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
8098 cust
->locations_valid
= 1;
8100 if (gcc_4_minor
>= 5)
8101 cust
->epilogue_unwind_valid
= 1;
8103 cust
->call_site_htab
= cu
->call_site_htab
;
8106 if (dwarf2_per_objfile
->using_index
)
8107 per_cu
->v
.quick
->compunit_symtab
= cust
;
8110 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8111 pst
->compunit_symtab
= cust
;
8115 /* Push it for inclusion processing later. */
8116 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
8118 do_cleanups (back_to
);
8121 /* Generate full symbol information for type unit PER_CU, whose DIEs have
8122 already been loaded into memory. */
8125 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
8126 enum language pretend_language
)
8128 struct dwarf2_cu
*cu
= per_cu
->cu
;
8129 struct objfile
*objfile
= per_cu
->objfile
;
8130 struct compunit_symtab
*cust
;
8131 struct cleanup
*back_to
, *delayed_list_cleanup
;
8132 struct signatured_type
*sig_type
;
8134 gdb_assert (per_cu
->is_debug_types
);
8135 sig_type
= (struct signatured_type
*) per_cu
;
8138 back_to
= make_cleanup (really_free_pendings
, NULL
);
8139 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8141 cu
->list_in_scope
= &file_symbols
;
8143 cu
->language
= pretend_language
;
8144 cu
->language_defn
= language_def (cu
->language
);
8146 /* The symbol tables are set up in read_type_unit_scope. */
8147 process_die (cu
->dies
, cu
);
8149 /* For now fudge the Go package. */
8150 if (cu
->language
== language_go
)
8151 fixup_go_packaging (cu
);
8153 /* Now that we have processed all the DIEs in the CU, all the types
8154 should be complete, and it should now be safe to compute all of the
8156 compute_delayed_physnames (cu
);
8157 do_cleanups (delayed_list_cleanup
);
8159 /* TUs share symbol tables.
8160 If this is the first TU to use this symtab, complete the construction
8161 of it with end_expandable_symtab. Otherwise, complete the addition of
8162 this TU's symbols to the existing symtab. */
8163 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
8165 cust
= end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
8166 sig_type
->type_unit_group
->compunit_symtab
= cust
;
8170 /* Set symtab language to language from DW_AT_language. If the
8171 compilation is from a C file generated by language preprocessors,
8172 do not set the language if it was already deduced by
8174 if (!(cu
->language
== language_c
8175 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
8176 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8181 augment_type_symtab ();
8182 cust
= sig_type
->type_unit_group
->compunit_symtab
;
8185 if (dwarf2_per_objfile
->using_index
)
8186 per_cu
->v
.quick
->compunit_symtab
= cust
;
8189 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8190 pst
->compunit_symtab
= cust
;
8194 do_cleanups (back_to
);
8197 /* Process an imported unit DIE. */
8200 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8202 struct attribute
*attr
;
8204 /* For now we don't handle imported units in type units. */
8205 if (cu
->per_cu
->is_debug_types
)
8207 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8208 " supported in type units [in module %s]"),
8209 objfile_name (cu
->objfile
));
8212 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8215 struct dwarf2_per_cu_data
*per_cu
;
8216 struct symtab
*imported_symtab
;
8220 offset
= dwarf2_get_ref_die_offset (attr
);
8221 is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
8222 per_cu
= dwarf2_find_containing_comp_unit (offset
, is_dwz
, cu
->objfile
);
8224 /* If necessary, add it to the queue and load its DIEs. */
8225 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
8226 load_full_comp_unit (per_cu
, cu
->language
);
8228 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8233 /* Reset the in_process bit of a die. */
8236 reset_die_in_process (void *arg
)
8238 struct die_info
*die
= arg
;
8240 die
->in_process
= 0;
8243 /* Process a die and its children. */
8246 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8248 struct cleanup
*in_process
;
8250 /* We should only be processing those not already in process. */
8251 gdb_assert (!die
->in_process
);
8253 die
->in_process
= 1;
8254 in_process
= make_cleanup (reset_die_in_process
,die
);
8258 case DW_TAG_padding
:
8260 case DW_TAG_compile_unit
:
8261 case DW_TAG_partial_unit
:
8262 read_file_scope (die
, cu
);
8264 case DW_TAG_type_unit
:
8265 read_type_unit_scope (die
, cu
);
8267 case DW_TAG_subprogram
:
8268 case DW_TAG_inlined_subroutine
:
8269 read_func_scope (die
, cu
);
8271 case DW_TAG_lexical_block
:
8272 case DW_TAG_try_block
:
8273 case DW_TAG_catch_block
:
8274 read_lexical_block_scope (die
, cu
);
8276 case DW_TAG_GNU_call_site
:
8277 read_call_site_scope (die
, cu
);
8279 case DW_TAG_class_type
:
8280 case DW_TAG_interface_type
:
8281 case DW_TAG_structure_type
:
8282 case DW_TAG_union_type
:
8283 process_structure_scope (die
, cu
);
8285 case DW_TAG_enumeration_type
:
8286 process_enumeration_scope (die
, cu
);
8289 /* These dies have a type, but processing them does not create
8290 a symbol or recurse to process the children. Therefore we can
8291 read them on-demand through read_type_die. */
8292 case DW_TAG_subroutine_type
:
8293 case DW_TAG_set_type
:
8294 case DW_TAG_array_type
:
8295 case DW_TAG_pointer_type
:
8296 case DW_TAG_ptr_to_member_type
:
8297 case DW_TAG_reference_type
:
8298 case DW_TAG_string_type
:
8301 case DW_TAG_base_type
:
8302 case DW_TAG_subrange_type
:
8303 case DW_TAG_typedef
:
8304 /* Add a typedef symbol for the type definition, if it has a
8306 new_symbol (die
, read_type_die (die
, cu
), cu
);
8308 case DW_TAG_common_block
:
8309 read_common_block (die
, cu
);
8311 case DW_TAG_common_inclusion
:
8313 case DW_TAG_namespace
:
8314 cu
->processing_has_namespace_info
= 1;
8315 read_namespace (die
, cu
);
8318 cu
->processing_has_namespace_info
= 1;
8319 read_module (die
, cu
);
8321 case DW_TAG_imported_declaration
:
8322 cu
->processing_has_namespace_info
= 1;
8323 if (read_namespace_alias (die
, cu
))
8325 /* The declaration is not a global namespace alias: fall through. */
8326 case DW_TAG_imported_module
:
8327 cu
->processing_has_namespace_info
= 1;
8328 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
8329 || cu
->language
!= language_fortran
))
8330 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
8331 dwarf_tag_name (die
->tag
));
8332 read_import_statement (die
, cu
);
8335 case DW_TAG_imported_unit
:
8336 process_imported_unit_die (die
, cu
);
8340 new_symbol (die
, NULL
, cu
);
8344 do_cleanups (in_process
);
8347 /* DWARF name computation. */
8349 /* A helper function for dwarf2_compute_name which determines whether DIE
8350 needs to have the name of the scope prepended to the name listed in the
8354 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8356 struct attribute
*attr
;
8360 case DW_TAG_namespace
:
8361 case DW_TAG_typedef
:
8362 case DW_TAG_class_type
:
8363 case DW_TAG_interface_type
:
8364 case DW_TAG_structure_type
:
8365 case DW_TAG_union_type
:
8366 case DW_TAG_enumeration_type
:
8367 case DW_TAG_enumerator
:
8368 case DW_TAG_subprogram
:
8369 case DW_TAG_inlined_subroutine
:
8371 case DW_TAG_imported_declaration
:
8374 case DW_TAG_variable
:
8375 case DW_TAG_constant
:
8376 /* We only need to prefix "globally" visible variables. These include
8377 any variable marked with DW_AT_external or any variable that
8378 lives in a namespace. [Variables in anonymous namespaces
8379 require prefixing, but they are not DW_AT_external.] */
8381 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
8383 struct dwarf2_cu
*spec_cu
= cu
;
8385 return die_needs_namespace (die_specification (die
, &spec_cu
),
8389 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
8390 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
8391 && die
->parent
->tag
!= DW_TAG_module
)
8393 /* A variable in a lexical block of some kind does not need a
8394 namespace, even though in C++ such variables may be external
8395 and have a mangled name. */
8396 if (die
->parent
->tag
== DW_TAG_lexical_block
8397 || die
->parent
->tag
== DW_TAG_try_block
8398 || die
->parent
->tag
== DW_TAG_catch_block
8399 || die
->parent
->tag
== DW_TAG_subprogram
)
8408 /* Retrieve the last character from a mem_file. */
8411 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
8413 char *last_char_p
= (char *) object
;
8416 *last_char_p
= buffer
[length
- 1];
8419 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8420 compute the physname for the object, which include a method's:
8421 - formal parameters (C++/Java),
8422 - receiver type (Go),
8423 - return type (Java).
8425 The term "physname" is a bit confusing.
8426 For C++, for example, it is the demangled name.
8427 For Go, for example, it's the mangled name.
8429 For Ada, return the DIE's linkage name rather than the fully qualified
8430 name. PHYSNAME is ignored..
8432 The result is allocated on the objfile_obstack and canonicalized. */
8435 dwarf2_compute_name (const char *name
,
8436 struct die_info
*die
, struct dwarf2_cu
*cu
,
8439 struct objfile
*objfile
= cu
->objfile
;
8442 name
= dwarf2_name (die
, cu
);
8444 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8445 compute it by typename_concat inside GDB. */
8446 if (cu
->language
== language_ada
8447 || (cu
->language
== language_fortran
&& physname
))
8449 /* For Ada unit, we prefer the linkage name over the name, as
8450 the former contains the exported name, which the user expects
8451 to be able to reference. Ideally, we want the user to be able
8452 to reference this entity using either natural or linkage name,
8453 but we haven't started looking at this enhancement yet. */
8454 struct attribute
*attr
;
8456 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8458 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8459 if (attr
&& DW_STRING (attr
))
8460 return DW_STRING (attr
);
8463 /* These are the only languages we know how to qualify names in. */
8465 && (cu
->language
== language_cplus
|| cu
->language
== language_java
8466 || cu
->language
== language_fortran
))
8468 if (die_needs_namespace (die
, cu
))
8472 struct ui_file
*buf
;
8473 char *intermediate_name
;
8474 const char *canonical_name
= NULL
;
8476 prefix
= determine_prefix (die
, cu
);
8477 buf
= mem_fileopen ();
8478 if (*prefix
!= '\0')
8480 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
8483 fputs_unfiltered (prefixed_name
, buf
);
8484 xfree (prefixed_name
);
8487 fputs_unfiltered (name
, buf
);
8489 /* Template parameters may be specified in the DIE's DW_AT_name, or
8490 as children with DW_TAG_template_type_param or
8491 DW_TAG_value_type_param. If the latter, add them to the name
8492 here. If the name already has template parameters, then
8493 skip this step; some versions of GCC emit both, and
8494 it is more efficient to use the pre-computed name.
8496 Something to keep in mind about this process: it is very
8497 unlikely, or in some cases downright impossible, to produce
8498 something that will match the mangled name of a function.
8499 If the definition of the function has the same debug info,
8500 we should be able to match up with it anyway. But fallbacks
8501 using the minimal symbol, for instance to find a method
8502 implemented in a stripped copy of libstdc++, will not work.
8503 If we do not have debug info for the definition, we will have to
8504 match them up some other way.
8506 When we do name matching there is a related problem with function
8507 templates; two instantiated function templates are allowed to
8508 differ only by their return types, which we do not add here. */
8510 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
8512 struct attribute
*attr
;
8513 struct die_info
*child
;
8516 die
->building_fullname
= 1;
8518 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
8522 const gdb_byte
*bytes
;
8523 struct dwarf2_locexpr_baton
*baton
;
8526 if (child
->tag
!= DW_TAG_template_type_param
8527 && child
->tag
!= DW_TAG_template_value_param
)
8532 fputs_unfiltered ("<", buf
);
8536 fputs_unfiltered (", ", buf
);
8538 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
8541 complaint (&symfile_complaints
,
8542 _("template parameter missing DW_AT_type"));
8543 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
8546 type
= die_type (child
, cu
);
8548 if (child
->tag
== DW_TAG_template_type_param
)
8550 c_print_type (type
, "", buf
, -1, 0, &type_print_raw_options
);
8554 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
8557 complaint (&symfile_complaints
,
8558 _("template parameter missing "
8559 "DW_AT_const_value"));
8560 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
8564 dwarf2_const_value_attr (attr
, type
, name
,
8565 &cu
->comp_unit_obstack
, cu
,
8566 &value
, &bytes
, &baton
);
8568 if (TYPE_NOSIGN (type
))
8569 /* GDB prints characters as NUMBER 'CHAR'. If that's
8570 changed, this can use value_print instead. */
8571 c_printchar (value
, type
, buf
);
8574 struct value_print_options opts
;
8577 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
8581 else if (bytes
!= NULL
)
8583 v
= allocate_value (type
);
8584 memcpy (value_contents_writeable (v
), bytes
,
8585 TYPE_LENGTH (type
));
8588 v
= value_from_longest (type
, value
);
8590 /* Specify decimal so that we do not depend on
8592 get_formatted_print_options (&opts
, 'd');
8594 value_print (v
, buf
, &opts
);
8600 die
->building_fullname
= 0;
8604 /* Close the argument list, with a space if necessary
8605 (nested templates). */
8606 char last_char
= '\0';
8607 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
8608 if (last_char
== '>')
8609 fputs_unfiltered (" >", buf
);
8611 fputs_unfiltered (">", buf
);
8615 /* For Java and C++ methods, append formal parameter type
8616 information, if PHYSNAME. */
8618 if (physname
&& die
->tag
== DW_TAG_subprogram
8619 && (cu
->language
== language_cplus
8620 || cu
->language
== language_java
))
8622 struct type
*type
= read_type_die (die
, cu
);
8624 c_type_print_args (type
, buf
, 1, cu
->language
,
8625 &type_print_raw_options
);
8627 if (cu
->language
== language_java
)
8629 /* For java, we must append the return type to method
8631 if (die
->tag
== DW_TAG_subprogram
)
8632 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
8633 0, 0, &type_print_raw_options
);
8635 else if (cu
->language
== language_cplus
)
8637 /* Assume that an artificial first parameter is
8638 "this", but do not crash if it is not. RealView
8639 marks unnamed (and thus unused) parameters as
8640 artificial; there is no way to differentiate
8642 if (TYPE_NFIELDS (type
) > 0
8643 && TYPE_FIELD_ARTIFICIAL (type
, 0)
8644 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
8645 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
8647 fputs_unfiltered (" const", buf
);
8651 intermediate_name
= ui_file_xstrdup (buf
, &length
);
8652 ui_file_delete (buf
);
8654 if (cu
->language
== language_cplus
)
8656 = dwarf2_canonicalize_name (intermediate_name
, cu
,
8657 &objfile
->per_bfd
->storage_obstack
);
8659 /* If we only computed INTERMEDIATE_NAME, or if
8660 INTERMEDIATE_NAME is already canonical, then we need to
8661 copy it to the appropriate obstack. */
8662 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
)
8663 name
= obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8665 strlen (intermediate_name
));
8667 name
= canonical_name
;
8669 xfree (intermediate_name
);
8676 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8677 If scope qualifiers are appropriate they will be added. The result
8678 will be allocated on the storage_obstack, or NULL if the DIE does
8679 not have a name. NAME may either be from a previous call to
8680 dwarf2_name or NULL.
8682 The output string will be canonicalized (if C++/Java). */
8685 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8687 return dwarf2_compute_name (name
, die
, cu
, 0);
8690 /* Construct a physname for the given DIE in CU. NAME may either be
8691 from a previous call to dwarf2_name or NULL. The result will be
8692 allocated on the objfile_objstack or NULL if the DIE does not have a
8695 The output string will be canonicalized (if C++/Java). */
8698 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8700 struct objfile
*objfile
= cu
->objfile
;
8701 struct attribute
*attr
;
8702 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
8703 struct cleanup
*back_to
;
8706 /* In this case dwarf2_compute_name is just a shortcut not building anything
8708 if (!die_needs_namespace (die
, cu
))
8709 return dwarf2_compute_name (name
, die
, cu
, 1);
8711 back_to
= make_cleanup (null_cleanup
, NULL
);
8713 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8715 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8717 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8719 if (attr
&& DW_STRING (attr
))
8723 mangled
= DW_STRING (attr
);
8725 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8726 type. It is easier for GDB users to search for such functions as
8727 `name(params)' than `long name(params)'. In such case the minimal
8728 symbol names do not match the full symbol names but for template
8729 functions there is never a need to look up their definition from their
8730 declaration so the only disadvantage remains the minimal symbol
8731 variant `long name(params)' does not have the proper inferior type.
8734 if (cu
->language
== language_go
)
8736 /* This is a lie, but we already lie to the caller new_symbol_full.
8737 new_symbol_full assumes we return the mangled name.
8738 This just undoes that lie until things are cleaned up. */
8743 demangled
= gdb_demangle (mangled
,
8744 (DMGL_PARAMS
| DMGL_ANSI
8745 | (cu
->language
== language_java
8746 ? DMGL_JAVA
| DMGL_RET_POSTFIX
8751 make_cleanup (xfree
, demangled
);
8761 if (canon
== NULL
|| check_physname
)
8763 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
8765 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
8767 /* It may not mean a bug in GDB. The compiler could also
8768 compute DW_AT_linkage_name incorrectly. But in such case
8769 GDB would need to be bug-to-bug compatible. */
8771 complaint (&symfile_complaints
,
8772 _("Computed physname <%s> does not match demangled <%s> "
8773 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8774 physname
, canon
, mangled
, die
->offset
.sect_off
,
8775 objfile_name (objfile
));
8777 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8778 is available here - over computed PHYSNAME. It is safer
8779 against both buggy GDB and buggy compilers. */
8793 retval
= obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8794 retval
, strlen (retval
));
8796 do_cleanups (back_to
);
8800 /* Inspect DIE in CU for a namespace alias. If one exists, record
8801 a new symbol for it.
8803 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8806 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
8808 struct attribute
*attr
;
8810 /* If the die does not have a name, this is not a namespace
8812 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8816 struct die_info
*d
= die
;
8817 struct dwarf2_cu
*imported_cu
= cu
;
8819 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8820 keep inspecting DIEs until we hit the underlying import. */
8821 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8822 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
8824 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
8828 d
= follow_die_ref (d
, attr
, &imported_cu
);
8829 if (d
->tag
!= DW_TAG_imported_declaration
)
8833 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
8835 complaint (&symfile_complaints
,
8836 _("DIE at 0x%x has too many recursively imported "
8837 "declarations"), d
->offset
.sect_off
);
8844 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
8846 type
= get_die_type_at_offset (offset
, cu
->per_cu
);
8847 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
8849 /* This declaration is a global namespace alias. Add
8850 a symbol for it whose type is the aliased namespace. */
8851 new_symbol (die
, type
, cu
);
8860 /* Read the import statement specified by the given die and record it. */
8863 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
8865 struct objfile
*objfile
= cu
->objfile
;
8866 struct attribute
*import_attr
;
8867 struct die_info
*imported_die
, *child_die
;
8868 struct dwarf2_cu
*imported_cu
;
8869 const char *imported_name
;
8870 const char *imported_name_prefix
;
8871 const char *canonical_name
;
8872 const char *import_alias
;
8873 const char *imported_declaration
= NULL
;
8874 const char *import_prefix
;
8875 VEC (const_char_ptr
) *excludes
= NULL
;
8876 struct cleanup
*cleanups
;
8878 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8879 if (import_attr
== NULL
)
8881 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8882 dwarf_tag_name (die
->tag
));
8887 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
8888 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8889 if (imported_name
== NULL
)
8891 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8893 The import in the following code:
8907 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8908 <52> DW_AT_decl_file : 1
8909 <53> DW_AT_decl_line : 6
8910 <54> DW_AT_import : <0x75>
8911 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8913 <5b> DW_AT_decl_file : 1
8914 <5c> DW_AT_decl_line : 2
8915 <5d> DW_AT_type : <0x6e>
8917 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8918 <76> DW_AT_byte_size : 4
8919 <77> DW_AT_encoding : 5 (signed)
8921 imports the wrong die ( 0x75 instead of 0x58 ).
8922 This case will be ignored until the gcc bug is fixed. */
8926 /* Figure out the local name after import. */
8927 import_alias
= dwarf2_name (die
, cu
);
8929 /* Figure out where the statement is being imported to. */
8930 import_prefix
= determine_prefix (die
, cu
);
8932 /* Figure out what the scope of the imported die is and prepend it
8933 to the name of the imported die. */
8934 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
8936 if (imported_die
->tag
!= DW_TAG_namespace
8937 && imported_die
->tag
!= DW_TAG_module
)
8939 imported_declaration
= imported_name
;
8940 canonical_name
= imported_name_prefix
;
8942 else if (strlen (imported_name_prefix
) > 0)
8943 canonical_name
= obconcat (&objfile
->objfile_obstack
,
8944 imported_name_prefix
, "::", imported_name
,
8947 canonical_name
= imported_name
;
8949 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
8951 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
8952 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
8953 child_die
= sibling_die (child_die
))
8955 /* DWARF-4: A Fortran use statement with a “rename list” may be
8956 represented by an imported module entry with an import attribute
8957 referring to the module and owned entries corresponding to those
8958 entities that are renamed as part of being imported. */
8960 if (child_die
->tag
!= DW_TAG_imported_declaration
)
8962 complaint (&symfile_complaints
,
8963 _("child DW_TAG_imported_declaration expected "
8964 "- DIE at 0x%x [in module %s]"),
8965 child_die
->offset
.sect_off
, objfile_name (objfile
));
8969 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
8970 if (import_attr
== NULL
)
8972 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8973 dwarf_tag_name (child_die
->tag
));
8978 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
8980 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8981 if (imported_name
== NULL
)
8983 complaint (&symfile_complaints
,
8984 _("child DW_TAG_imported_declaration has unknown "
8985 "imported name - DIE at 0x%x [in module %s]"),
8986 child_die
->offset
.sect_off
, objfile_name (objfile
));
8990 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
8992 process_die (child_die
, cu
);
8995 cp_add_using_directive (import_prefix
,
8998 imported_declaration
,
9001 &objfile
->objfile_obstack
);
9003 do_cleanups (cleanups
);
9006 /* Cleanup function for handle_DW_AT_stmt_list. */
9009 free_cu_line_header (void *arg
)
9011 struct dwarf2_cu
*cu
= arg
;
9013 free_line_header (cu
->line_header
);
9014 cu
->line_header
= NULL
;
9017 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
9018 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
9019 this, it was first present in GCC release 4.3.0. */
9022 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
9024 if (!cu
->checked_producer
)
9025 check_producer (cu
);
9027 return cu
->producer_is_gcc_lt_4_3
;
9031 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
9032 const char **name
, const char **comp_dir
)
9034 struct attribute
*attr
;
9039 /* Find the filename. Do not use dwarf2_name here, since the filename
9040 is not a source language identifier. */
9041 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
9044 *name
= DW_STRING (attr
);
9047 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
9049 *comp_dir
= DW_STRING (attr
);
9050 else if (producer_is_gcc_lt_4_3 (cu
) && *name
!= NULL
9051 && IS_ABSOLUTE_PATH (*name
))
9053 char *d
= ldirname (*name
);
9057 make_cleanup (xfree
, d
);
9059 if (*comp_dir
!= NULL
)
9061 /* Irix 6.2 native cc prepends <machine>.: to the compilation
9062 directory, get rid of it. */
9063 char *cp
= strchr (*comp_dir
, ':');
9065 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
9070 *name
= "<unknown>";
9073 /* Handle DW_AT_stmt_list for a compilation unit.
9074 DIE is the DW_TAG_compile_unit die for CU.
9075 COMP_DIR is the compilation directory. LOWPC is passed to
9076 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
9079 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
9080 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
9082 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9083 struct attribute
*attr
;
9084 unsigned int line_offset
;
9085 struct line_header line_header_local
;
9086 hashval_t line_header_local_hash
;
9091 gdb_assert (! cu
->per_cu
->is_debug_types
);
9093 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9097 line_offset
= DW_UNSND (attr
);
9099 /* The line header hash table is only created if needed (it exists to
9100 prevent redundant reading of the line table for partial_units).
9101 If we're given a partial_unit, we'll need it. If we're given a
9102 compile_unit, then use the line header hash table if it's already
9103 created, but don't create one just yet. */
9105 if (dwarf2_per_objfile
->line_header_hash
== NULL
9106 && die
->tag
== DW_TAG_partial_unit
)
9108 dwarf2_per_objfile
->line_header_hash
9109 = htab_create_alloc_ex (127, line_header_hash_voidp
,
9110 line_header_eq_voidp
,
9111 free_line_header_voidp
,
9112 &objfile
->objfile_obstack
,
9113 hashtab_obstack_allocate
,
9114 dummy_obstack_deallocate
);
9117 line_header_local
.offset
.sect_off
= line_offset
;
9118 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
9119 line_header_local_hash
= line_header_hash (&line_header_local
);
9120 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
9122 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9124 line_header_local_hash
, NO_INSERT
);
9126 /* For DW_TAG_compile_unit we need info like symtab::linetable which
9127 is not present in *SLOT (since if there is something in *SLOT then
9128 it will be for a partial_unit). */
9129 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
9131 gdb_assert (*slot
!= NULL
);
9132 cu
->line_header
= *slot
;
9137 /* dwarf_decode_line_header does not yet provide sufficient information.
9138 We always have to call also dwarf_decode_lines for it. */
9139 cu
->line_header
= dwarf_decode_line_header (line_offset
, cu
);
9140 if (cu
->line_header
== NULL
)
9143 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
9147 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9149 line_header_local_hash
, INSERT
);
9150 gdb_assert (slot
!= NULL
);
9152 if (slot
!= NULL
&& *slot
== NULL
)
9154 /* This newly decoded line number information unit will be owned
9155 by line_header_hash hash table. */
9156 *slot
= cu
->line_header
;
9160 /* We cannot free any current entry in (*slot) as that struct line_header
9161 may be already used by multiple CUs. Create only temporary decoded
9162 line_header for this CU - it may happen at most once for each line
9163 number information unit. And if we're not using line_header_hash
9164 then this is what we want as well. */
9165 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
9166 make_cleanup (free_cu_line_header
, cu
);
9168 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
9169 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
9173 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
9176 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9178 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9179 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9180 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
9181 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
9182 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
9183 struct attribute
*attr
;
9184 const char *name
= NULL
;
9185 const char *comp_dir
= NULL
;
9186 struct die_info
*child_die
;
9187 bfd
*abfd
= objfile
->obfd
;
9190 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9192 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
9194 /* If we didn't find a lowpc, set it to highpc to avoid complaints
9195 from finish_block. */
9196 if (lowpc
== ((CORE_ADDR
) -1))
9198 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
9200 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
9202 prepare_one_comp_unit (cu
, die
, cu
->language
);
9204 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
9205 standardised yet. As a workaround for the language detection we fall
9206 back to the DW_AT_producer string. */
9207 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
9208 cu
->language
= language_opencl
;
9210 /* Similar hack for Go. */
9211 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
9212 set_cu_language (DW_LANG_Go
, cu
);
9214 dwarf2_start_symtab (cu
, name
, comp_dir
, lowpc
);
9216 /* Decode line number information if present. We do this before
9217 processing child DIEs, so that the line header table is available
9218 for DW_AT_decl_file. */
9219 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, lowpc
);
9221 /* Process all dies in compilation unit. */
9222 if (die
->child
!= NULL
)
9224 child_die
= die
->child
;
9225 while (child_die
&& child_die
->tag
)
9227 process_die (child_die
, cu
);
9228 child_die
= sibling_die (child_die
);
9232 /* Decode macro information, if present. Dwarf 2 macro information
9233 refers to information in the line number info statement program
9234 header, so we can only read it if we've read the header
9236 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
9237 if (attr
&& cu
->line_header
)
9239 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
9240 complaint (&symfile_complaints
,
9241 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
9243 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
9247 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
9248 if (attr
&& cu
->line_header
)
9250 unsigned int macro_offset
= DW_UNSND (attr
);
9252 dwarf_decode_macros (cu
, macro_offset
, 0);
9256 do_cleanups (back_to
);
9259 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
9260 Create the set of symtabs used by this TU, or if this TU is sharing
9261 symtabs with another TU and the symtabs have already been created
9262 then restore those symtabs in the line header.
9263 We don't need the pc/line-number mapping for type units. */
9266 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
9268 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9269 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
9270 struct type_unit_group
*tu_group
;
9272 struct line_header
*lh
;
9273 struct attribute
*attr
;
9274 unsigned int i
, line_offset
;
9275 struct signatured_type
*sig_type
;
9277 gdb_assert (per_cu
->is_debug_types
);
9278 sig_type
= (struct signatured_type
*) per_cu
;
9280 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9282 /* If we're using .gdb_index (includes -readnow) then
9283 per_cu->type_unit_group may not have been set up yet. */
9284 if (sig_type
->type_unit_group
== NULL
)
9285 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
9286 tu_group
= sig_type
->type_unit_group
;
9288 /* If we've already processed this stmt_list there's no real need to
9289 do it again, we could fake it and just recreate the part we need
9290 (file name,index -> symtab mapping). If data shows this optimization
9291 is useful we can do it then. */
9292 first_time
= tu_group
->compunit_symtab
== NULL
;
9294 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9299 line_offset
= DW_UNSND (attr
);
9300 lh
= dwarf_decode_line_header (line_offset
, cu
);
9305 dwarf2_start_symtab (cu
, "", NULL
, 0);
9308 gdb_assert (tu_group
->symtabs
== NULL
);
9309 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9314 cu
->line_header
= lh
;
9315 make_cleanup (free_cu_line_header
, cu
);
9319 struct compunit_symtab
*cust
= dwarf2_start_symtab (cu
, "", NULL
, 0);
9321 tu_group
->num_symtabs
= lh
->num_file_names
;
9322 tu_group
->symtabs
= XNEWVEC (struct symtab
*, lh
->num_file_names
);
9324 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9326 const char *dir
= NULL
;
9327 struct file_entry
*fe
= &lh
->file_names
[i
];
9329 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
9330 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9331 dwarf2_start_subfile (fe
->name
, dir
);
9333 if (current_subfile
->symtab
== NULL
)
9335 /* NOTE: start_subfile will recognize when it's been passed
9336 a file it has already seen. So we can't assume there's a
9337 simple mapping from lh->file_names to subfiles, plus
9338 lh->file_names may contain dups. */
9339 current_subfile
->symtab
9340 = allocate_symtab (cust
, current_subfile
->name
);
9343 fe
->symtab
= current_subfile
->symtab
;
9344 tu_group
->symtabs
[i
] = fe
->symtab
;
9349 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9351 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9353 struct file_entry
*fe
= &lh
->file_names
[i
];
9355 fe
->symtab
= tu_group
->symtabs
[i
];
9359 /* The main symtab is allocated last. Type units don't have DW_AT_name
9360 so they don't have a "real" (so to speak) symtab anyway.
9361 There is later code that will assign the main symtab to all symbols
9362 that don't have one. We need to handle the case of a symbol with a
9363 missing symtab (DW_AT_decl_file) anyway. */
9366 /* Process DW_TAG_type_unit.
9367 For TUs we want to skip the first top level sibling if it's not the
9368 actual type being defined by this TU. In this case the first top
9369 level sibling is there to provide context only. */
9372 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9374 struct die_info
*child_die
;
9376 prepare_one_comp_unit (cu
, die
, language_minimal
);
9378 /* Initialize (or reinitialize) the machinery for building symtabs.
9379 We do this before processing child DIEs, so that the line header table
9380 is available for DW_AT_decl_file. */
9381 setup_type_unit_groups (die
, cu
);
9383 if (die
->child
!= NULL
)
9385 child_die
= die
->child
;
9386 while (child_die
&& child_die
->tag
)
9388 process_die (child_die
, cu
);
9389 child_die
= sibling_die (child_die
);
9396 http://gcc.gnu.org/wiki/DebugFission
9397 http://gcc.gnu.org/wiki/DebugFissionDWP
9399 To simplify handling of both DWO files ("object" files with the DWARF info)
9400 and DWP files (a file with the DWOs packaged up into one file), we treat
9401 DWP files as having a collection of virtual DWO files. */
9404 hash_dwo_file (const void *item
)
9406 const struct dwo_file
*dwo_file
= item
;
9409 hash
= htab_hash_string (dwo_file
->dwo_name
);
9410 if (dwo_file
->comp_dir
!= NULL
)
9411 hash
+= htab_hash_string (dwo_file
->comp_dir
);
9416 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
9418 const struct dwo_file
*lhs
= item_lhs
;
9419 const struct dwo_file
*rhs
= item_rhs
;
9421 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
9423 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
9424 return lhs
->comp_dir
== rhs
->comp_dir
;
9425 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
9428 /* Allocate a hash table for DWO files. */
9431 allocate_dwo_file_hash_table (void)
9433 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9435 return htab_create_alloc_ex (41,
9439 &objfile
->objfile_obstack
,
9440 hashtab_obstack_allocate
,
9441 dummy_obstack_deallocate
);
9444 /* Lookup DWO file DWO_NAME. */
9447 lookup_dwo_file_slot (const char *dwo_name
, const char *comp_dir
)
9449 struct dwo_file find_entry
;
9452 if (dwarf2_per_objfile
->dwo_files
== NULL
)
9453 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
9455 memset (&find_entry
, 0, sizeof (find_entry
));
9456 find_entry
.dwo_name
= dwo_name
;
9457 find_entry
.comp_dir
= comp_dir
;
9458 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
9464 hash_dwo_unit (const void *item
)
9466 const struct dwo_unit
*dwo_unit
= item
;
9468 /* This drops the top 32 bits of the id, but is ok for a hash. */
9469 return dwo_unit
->signature
;
9473 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
9475 const struct dwo_unit
*lhs
= item_lhs
;
9476 const struct dwo_unit
*rhs
= item_rhs
;
9478 /* The signature is assumed to be unique within the DWO file.
9479 So while object file CU dwo_id's always have the value zero,
9480 that's OK, assuming each object file DWO file has only one CU,
9481 and that's the rule for now. */
9482 return lhs
->signature
== rhs
->signature
;
9485 /* Allocate a hash table for DWO CUs,TUs.
9486 There is one of these tables for each of CUs,TUs for each DWO file. */
9489 allocate_dwo_unit_table (struct objfile
*objfile
)
9491 /* Start out with a pretty small number.
9492 Generally DWO files contain only one CU and maybe some TUs. */
9493 return htab_create_alloc_ex (3,
9497 &objfile
->objfile_obstack
,
9498 hashtab_obstack_allocate
,
9499 dummy_obstack_deallocate
);
9502 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9504 struct create_dwo_cu_data
9506 struct dwo_file
*dwo_file
;
9507 struct dwo_unit dwo_unit
;
9510 /* die_reader_func for create_dwo_cu. */
9513 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
9514 const gdb_byte
*info_ptr
,
9515 struct die_info
*comp_unit_die
,
9519 struct dwarf2_cu
*cu
= reader
->cu
;
9520 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9521 sect_offset offset
= cu
->per_cu
->offset
;
9522 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
9523 struct create_dwo_cu_data
*data
= datap
;
9524 struct dwo_file
*dwo_file
= data
->dwo_file
;
9525 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
9526 struct attribute
*attr
;
9528 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
9531 complaint (&symfile_complaints
,
9532 _("Dwarf Error: debug entry at offset 0x%x is missing"
9533 " its dwo_id [in module %s]"),
9534 offset
.sect_off
, dwo_file
->dwo_name
);
9538 dwo_unit
->dwo_file
= dwo_file
;
9539 dwo_unit
->signature
= DW_UNSND (attr
);
9540 dwo_unit
->section
= section
;
9541 dwo_unit
->offset
= offset
;
9542 dwo_unit
->length
= cu
->per_cu
->length
;
9544 if (dwarf_read_debug
)
9545 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id %s\n",
9546 offset
.sect_off
, hex_string (dwo_unit
->signature
));
9549 /* Create the dwo_unit for the lone CU in DWO_FILE.
9550 Note: This function processes DWO files only, not DWP files. */
9552 static struct dwo_unit
*
9553 create_dwo_cu (struct dwo_file
*dwo_file
)
9555 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9556 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
9559 const gdb_byte
*info_ptr
, *end_ptr
;
9560 struct create_dwo_cu_data create_dwo_cu_data
;
9561 struct dwo_unit
*dwo_unit
;
9563 dwarf2_read_section (objfile
, section
);
9564 info_ptr
= section
->buffer
;
9566 if (info_ptr
== NULL
)
9569 /* We can't set abfd until now because the section may be empty or
9570 not present, in which case section->asection will be NULL. */
9571 abfd
= get_section_bfd_owner (section
);
9573 if (dwarf_read_debug
)
9575 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
9576 get_section_name (section
),
9577 get_section_file_name (section
));
9580 create_dwo_cu_data
.dwo_file
= dwo_file
;
9583 end_ptr
= info_ptr
+ section
->size
;
9584 while (info_ptr
< end_ptr
)
9586 struct dwarf2_per_cu_data per_cu
;
9588 memset (&create_dwo_cu_data
.dwo_unit
, 0,
9589 sizeof (create_dwo_cu_data
.dwo_unit
));
9590 memset (&per_cu
, 0, sizeof (per_cu
));
9591 per_cu
.objfile
= objfile
;
9592 per_cu
.is_debug_types
= 0;
9593 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
9594 per_cu
.section
= section
;
9596 init_cutu_and_read_dies_no_follow (&per_cu
, dwo_file
,
9597 create_dwo_cu_reader
,
9598 &create_dwo_cu_data
);
9600 if (create_dwo_cu_data
.dwo_unit
.dwo_file
!= NULL
)
9602 /* If we've already found one, complain. We only support one
9603 because having more than one requires hacking the dwo_name of
9604 each to match, which is highly unlikely to happen. */
9605 if (dwo_unit
!= NULL
)
9607 complaint (&symfile_complaints
,
9608 _("Multiple CUs in DWO file %s [in module %s]"),
9609 dwo_file
->dwo_name
, objfile_name (objfile
));
9613 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
9614 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
9617 info_ptr
+= per_cu
.length
;
9623 /* DWP file .debug_{cu,tu}_index section format:
9624 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9628 Both index sections have the same format, and serve to map a 64-bit
9629 signature to a set of section numbers. Each section begins with a header,
9630 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9631 indexes, and a pool of 32-bit section numbers. The index sections will be
9632 aligned at 8-byte boundaries in the file.
9634 The index section header consists of:
9636 V, 32 bit version number
9638 N, 32 bit number of compilation units or type units in the index
9639 M, 32 bit number of slots in the hash table
9641 Numbers are recorded using the byte order of the application binary.
9643 The hash table begins at offset 16 in the section, and consists of an array
9644 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9645 order of the application binary). Unused slots in the hash table are 0.
9646 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9648 The parallel table begins immediately after the hash table
9649 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9650 array of 32-bit indexes (using the byte order of the application binary),
9651 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9652 table contains a 32-bit index into the pool of section numbers. For unused
9653 hash table slots, the corresponding entry in the parallel table will be 0.
9655 The pool of section numbers begins immediately following the hash table
9656 (at offset 16 + 12 * M from the beginning of the section). The pool of
9657 section numbers consists of an array of 32-bit words (using the byte order
9658 of the application binary). Each item in the array is indexed starting
9659 from 0. The hash table entry provides the index of the first section
9660 number in the set. Additional section numbers in the set follow, and the
9661 set is terminated by a 0 entry (section number 0 is not used in ELF).
9663 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9664 section must be the first entry in the set, and the .debug_abbrev.dwo must
9665 be the second entry. Other members of the set may follow in any order.
9671 DWP Version 2 combines all the .debug_info, etc. sections into one,
9672 and the entries in the index tables are now offsets into these sections.
9673 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9676 Index Section Contents:
9678 Hash Table of Signatures dwp_hash_table.hash_table
9679 Parallel Table of Indices dwp_hash_table.unit_table
9680 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9681 Table of Section Sizes dwp_hash_table.v2.sizes
9683 The index section header consists of:
9685 V, 32 bit version number
9686 L, 32 bit number of columns in the table of section offsets
9687 N, 32 bit number of compilation units or type units in the index
9688 M, 32 bit number of slots in the hash table
9690 Numbers are recorded using the byte order of the application binary.
9692 The hash table has the same format as version 1.
9693 The parallel table of indices has the same format as version 1,
9694 except that the entries are origin-1 indices into the table of sections
9695 offsets and the table of section sizes.
9697 The table of offsets begins immediately following the parallel table
9698 (at offset 16 + 12 * M from the beginning of the section). The table is
9699 a two-dimensional array of 32-bit words (using the byte order of the
9700 application binary), with L columns and N+1 rows, in row-major order.
9701 Each row in the array is indexed starting from 0. The first row provides
9702 a key to the remaining rows: each column in this row provides an identifier
9703 for a debug section, and the offsets in the same column of subsequent rows
9704 refer to that section. The section identifiers are:
9706 DW_SECT_INFO 1 .debug_info.dwo
9707 DW_SECT_TYPES 2 .debug_types.dwo
9708 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9709 DW_SECT_LINE 4 .debug_line.dwo
9710 DW_SECT_LOC 5 .debug_loc.dwo
9711 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9712 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9713 DW_SECT_MACRO 8 .debug_macro.dwo
9715 The offsets provided by the CU and TU index sections are the base offsets
9716 for the contributions made by each CU or TU to the corresponding section
9717 in the package file. Each CU and TU header contains an abbrev_offset
9718 field, used to find the abbreviations table for that CU or TU within the
9719 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9720 be interpreted as relative to the base offset given in the index section.
9721 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9722 should be interpreted as relative to the base offset for .debug_line.dwo,
9723 and offsets into other debug sections obtained from DWARF attributes should
9724 also be interpreted as relative to the corresponding base offset.
9726 The table of sizes begins immediately following the table of offsets.
9727 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9728 with L columns and N rows, in row-major order. Each row in the array is
9729 indexed starting from 1 (row 0 is shared by the two tables).
9733 Hash table lookup is handled the same in version 1 and 2:
9735 We assume that N and M will not exceed 2^32 - 1.
9736 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9738 Given a 64-bit compilation unit signature or a type signature S, an entry
9739 in the hash table is located as follows:
9741 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9742 the low-order k bits all set to 1.
9744 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9746 3) If the hash table entry at index H matches the signature, use that
9747 entry. If the hash table entry at index H is unused (all zeroes),
9748 terminate the search: the signature is not present in the table.
9750 4) Let H = (H + H') modulo M. Repeat at Step 3.
9752 Because M > N and H' and M are relatively prime, the search is guaranteed
9753 to stop at an unused slot or find the match. */
9755 /* Create a hash table to map DWO IDs to their CU/TU entry in
9756 .debug_{info,types}.dwo in DWP_FILE.
9757 Returns NULL if there isn't one.
9758 Note: This function processes DWP files only, not DWO files. */
9760 static struct dwp_hash_table
*
9761 create_dwp_hash_table (struct dwp_file
*dwp_file
, int is_debug_types
)
9763 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9764 bfd
*dbfd
= dwp_file
->dbfd
;
9765 const gdb_byte
*index_ptr
, *index_end
;
9766 struct dwarf2_section_info
*index
;
9767 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
9768 struct dwp_hash_table
*htab
;
9771 index
= &dwp_file
->sections
.tu_index
;
9773 index
= &dwp_file
->sections
.cu_index
;
9775 if (dwarf2_section_empty_p (index
))
9777 dwarf2_read_section (objfile
, index
);
9779 index_ptr
= index
->buffer
;
9780 index_end
= index_ptr
+ index
->size
;
9782 version
= read_4_bytes (dbfd
, index_ptr
);
9785 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
9789 nr_units
= read_4_bytes (dbfd
, index_ptr
);
9791 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
9794 if (version
!= 1 && version
!= 2)
9796 error (_("Dwarf Error: unsupported DWP file version (%s)"
9798 pulongest (version
), dwp_file
->name
);
9800 if (nr_slots
!= (nr_slots
& -nr_slots
))
9802 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9803 " is not power of 2 [in module %s]"),
9804 pulongest (nr_slots
), dwp_file
->name
);
9807 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
9808 htab
->version
= version
;
9809 htab
->nr_columns
= nr_columns
;
9810 htab
->nr_units
= nr_units
;
9811 htab
->nr_slots
= nr_slots
;
9812 htab
->hash_table
= index_ptr
;
9813 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
9815 /* Exit early if the table is empty. */
9816 if (nr_slots
== 0 || nr_units
== 0
9817 || (version
== 2 && nr_columns
== 0))
9819 /* All must be zero. */
9820 if (nr_slots
!= 0 || nr_units
!= 0
9821 || (version
== 2 && nr_columns
!= 0))
9823 complaint (&symfile_complaints
,
9824 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9825 " all zero [in modules %s]"),
9833 htab
->section_pool
.v1
.indices
=
9834 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9835 /* It's harder to decide whether the section is too small in v1.
9836 V1 is deprecated anyway so we punt. */
9840 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9841 int *ids
= htab
->section_pool
.v2
.section_ids
;
9842 /* Reverse map for error checking. */
9843 int ids_seen
[DW_SECT_MAX
+ 1];
9848 error (_("Dwarf Error: bad DWP hash table, too few columns"
9849 " in section table [in module %s]"),
9852 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
9854 error (_("Dwarf Error: bad DWP hash table, too many columns"
9855 " in section table [in module %s]"),
9858 memset (ids
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9859 memset (ids_seen
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9860 for (i
= 0; i
< nr_columns
; ++i
)
9862 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
9864 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
9866 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9867 " in section table [in module %s]"),
9868 id
, dwp_file
->name
);
9870 if (ids_seen
[id
] != -1)
9872 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9873 " id %d in section table [in module %s]"),
9874 id
, dwp_file
->name
);
9879 /* Must have exactly one info or types section. */
9880 if (((ids_seen
[DW_SECT_INFO
] != -1)
9881 + (ids_seen
[DW_SECT_TYPES
] != -1))
9884 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9885 " DWO info/types section [in module %s]"),
9888 /* Must have an abbrev section. */
9889 if (ids_seen
[DW_SECT_ABBREV
] == -1)
9891 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9892 " section [in module %s]"),
9895 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
9896 htab
->section_pool
.v2
.sizes
=
9897 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
9898 * nr_units
* nr_columns
);
9899 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
9900 * nr_units
* nr_columns
))
9903 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9912 /* Update SECTIONS with the data from SECTP.
9914 This function is like the other "locate" section routines that are
9915 passed to bfd_map_over_sections, but in this context the sections to
9916 read comes from the DWP V1 hash table, not the full ELF section table.
9918 The result is non-zero for success, or zero if an error was found. */
9921 locate_v1_virtual_dwo_sections (asection
*sectp
,
9922 struct virtual_v1_dwo_sections
*sections
)
9924 const struct dwop_section_names
*names
= &dwop_section_names
;
9926 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
9928 /* There can be only one. */
9929 if (sections
->abbrev
.s
.asection
!= NULL
)
9931 sections
->abbrev
.s
.asection
= sectp
;
9932 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
9934 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
9935 || section_is_p (sectp
->name
, &names
->types_dwo
))
9937 /* There can be only one. */
9938 if (sections
->info_or_types
.s
.asection
!= NULL
)
9940 sections
->info_or_types
.s
.asection
= sectp
;
9941 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
9943 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
9945 /* There can be only one. */
9946 if (sections
->line
.s
.asection
!= NULL
)
9948 sections
->line
.s
.asection
= sectp
;
9949 sections
->line
.size
= bfd_get_section_size (sectp
);
9951 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
9953 /* There can be only one. */
9954 if (sections
->loc
.s
.asection
!= NULL
)
9956 sections
->loc
.s
.asection
= sectp
;
9957 sections
->loc
.size
= bfd_get_section_size (sectp
);
9959 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
9961 /* There can be only one. */
9962 if (sections
->macinfo
.s
.asection
!= NULL
)
9964 sections
->macinfo
.s
.asection
= sectp
;
9965 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
9967 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
9969 /* There can be only one. */
9970 if (sections
->macro
.s
.asection
!= NULL
)
9972 sections
->macro
.s
.asection
= sectp
;
9973 sections
->macro
.size
= bfd_get_section_size (sectp
);
9975 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
9977 /* There can be only one. */
9978 if (sections
->str_offsets
.s
.asection
!= NULL
)
9980 sections
->str_offsets
.s
.asection
= sectp
;
9981 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
9985 /* No other kind of section is valid. */
9992 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9993 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9994 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9995 This is for DWP version 1 files. */
9997 static struct dwo_unit
*
9998 create_dwo_unit_in_dwp_v1 (struct dwp_file
*dwp_file
,
9999 uint32_t unit_index
,
10000 const char *comp_dir
,
10001 ULONGEST signature
, int is_debug_types
)
10003 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10004 const struct dwp_hash_table
*dwp_htab
=
10005 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10006 bfd
*dbfd
= dwp_file
->dbfd
;
10007 const char *kind
= is_debug_types
? "TU" : "CU";
10008 struct dwo_file
*dwo_file
;
10009 struct dwo_unit
*dwo_unit
;
10010 struct virtual_v1_dwo_sections sections
;
10011 void **dwo_file_slot
;
10012 char *virtual_dwo_name
;
10013 struct dwarf2_section_info
*cutu
;
10014 struct cleanup
*cleanups
;
10017 gdb_assert (dwp_file
->version
== 1);
10019 if (dwarf_read_debug
)
10021 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
10023 pulongest (unit_index
), hex_string (signature
),
10027 /* Fetch the sections of this DWO unit.
10028 Put a limit on the number of sections we look for so that bad data
10029 doesn't cause us to loop forever. */
10031 #define MAX_NR_V1_DWO_SECTIONS \
10032 (1 /* .debug_info or .debug_types */ \
10033 + 1 /* .debug_abbrev */ \
10034 + 1 /* .debug_line */ \
10035 + 1 /* .debug_loc */ \
10036 + 1 /* .debug_str_offsets */ \
10037 + 1 /* .debug_macro or .debug_macinfo */ \
10038 + 1 /* trailing zero */)
10040 memset (§ions
, 0, sizeof (sections
));
10041 cleanups
= make_cleanup (null_cleanup
, 0);
10043 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
10046 uint32_t section_nr
=
10047 read_4_bytes (dbfd
,
10048 dwp_htab
->section_pool
.v1
.indices
10049 + (unit_index
+ i
) * sizeof (uint32_t));
10051 if (section_nr
== 0)
10053 if (section_nr
>= dwp_file
->num_sections
)
10055 error (_("Dwarf Error: bad DWP hash table, section number too large"
10056 " [in module %s]"),
10060 sectp
= dwp_file
->elf_sections
[section_nr
];
10061 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
10063 error (_("Dwarf Error: bad DWP hash table, invalid section found"
10064 " [in module %s]"),
10070 || dwarf2_section_empty_p (§ions
.info_or_types
)
10071 || dwarf2_section_empty_p (§ions
.abbrev
))
10073 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
10074 " [in module %s]"),
10077 if (i
== MAX_NR_V1_DWO_SECTIONS
)
10079 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
10080 " [in module %s]"),
10084 /* It's easier for the rest of the code if we fake a struct dwo_file and
10085 have dwo_unit "live" in that. At least for now.
10087 The DWP file can be made up of a random collection of CUs and TUs.
10088 However, for each CU + set of TUs that came from the same original DWO
10089 file, we can combine them back into a virtual DWO file to save space
10090 (fewer struct dwo_file objects to allocate). Remember that for really
10091 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10094 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
10095 get_section_id (§ions
.abbrev
),
10096 get_section_id (§ions
.line
),
10097 get_section_id (§ions
.loc
),
10098 get_section_id (§ions
.str_offsets
));
10099 make_cleanup (xfree
, virtual_dwo_name
);
10100 /* Can we use an existing virtual DWO file? */
10101 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10102 /* Create one if necessary. */
10103 if (*dwo_file_slot
== NULL
)
10105 if (dwarf_read_debug
)
10107 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10110 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10111 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
10113 strlen (virtual_dwo_name
));
10114 dwo_file
->comp_dir
= comp_dir
;
10115 dwo_file
->sections
.abbrev
= sections
.abbrev
;
10116 dwo_file
->sections
.line
= sections
.line
;
10117 dwo_file
->sections
.loc
= sections
.loc
;
10118 dwo_file
->sections
.macinfo
= sections
.macinfo
;
10119 dwo_file
->sections
.macro
= sections
.macro
;
10120 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
10121 /* The "str" section is global to the entire DWP file. */
10122 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10123 /* The info or types section is assigned below to dwo_unit,
10124 there's no need to record it in dwo_file.
10125 Also, we can't simply record type sections in dwo_file because
10126 we record a pointer into the vector in dwo_unit. As we collect more
10127 types we'll grow the vector and eventually have to reallocate space
10128 for it, invalidating all copies of pointers into the previous
10130 *dwo_file_slot
= dwo_file
;
10134 if (dwarf_read_debug
)
10136 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10139 dwo_file
= *dwo_file_slot
;
10141 do_cleanups (cleanups
);
10143 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10144 dwo_unit
->dwo_file
= dwo_file
;
10145 dwo_unit
->signature
= signature
;
10146 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
10147 sizeof (struct dwarf2_section_info
));
10148 *dwo_unit
->section
= sections
.info_or_types
;
10149 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10154 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
10155 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
10156 piece within that section used by a TU/CU, return a virtual section
10157 of just that piece. */
10159 static struct dwarf2_section_info
10160 create_dwp_v2_section (struct dwarf2_section_info
*section
,
10161 bfd_size_type offset
, bfd_size_type size
)
10163 struct dwarf2_section_info result
;
10166 gdb_assert (section
!= NULL
);
10167 gdb_assert (!section
->is_virtual
);
10169 memset (&result
, 0, sizeof (result
));
10170 result
.s
.containing_section
= section
;
10171 result
.is_virtual
= 1;
10176 sectp
= get_section_bfd_section (section
);
10178 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
10179 bounds of the real section. This is a pretty-rare event, so just
10180 flag an error (easier) instead of a warning and trying to cope. */
10182 || offset
+ size
> bfd_get_section_size (sectp
))
10184 bfd
*abfd
= sectp
->owner
;
10186 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
10187 " in section %s [in module %s]"),
10188 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
10189 objfile_name (dwarf2_per_objfile
->objfile
));
10192 result
.virtual_offset
= offset
;
10193 result
.size
= size
;
10197 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10198 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10199 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10200 This is for DWP version 2 files. */
10202 static struct dwo_unit
*
10203 create_dwo_unit_in_dwp_v2 (struct dwp_file
*dwp_file
,
10204 uint32_t unit_index
,
10205 const char *comp_dir
,
10206 ULONGEST signature
, int is_debug_types
)
10208 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10209 const struct dwp_hash_table
*dwp_htab
=
10210 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10211 bfd
*dbfd
= dwp_file
->dbfd
;
10212 const char *kind
= is_debug_types
? "TU" : "CU";
10213 struct dwo_file
*dwo_file
;
10214 struct dwo_unit
*dwo_unit
;
10215 struct virtual_v2_dwo_sections sections
;
10216 void **dwo_file_slot
;
10217 char *virtual_dwo_name
;
10218 struct dwarf2_section_info
*cutu
;
10219 struct cleanup
*cleanups
;
10222 gdb_assert (dwp_file
->version
== 2);
10224 if (dwarf_read_debug
)
10226 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
10228 pulongest (unit_index
), hex_string (signature
),
10232 /* Fetch the section offsets of this DWO unit. */
10234 memset (§ions
, 0, sizeof (sections
));
10235 cleanups
= make_cleanup (null_cleanup
, 0);
10237 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
10239 uint32_t offset
= read_4_bytes (dbfd
,
10240 dwp_htab
->section_pool
.v2
.offsets
10241 + (((unit_index
- 1) * dwp_htab
->nr_columns
10243 * sizeof (uint32_t)));
10244 uint32_t size
= read_4_bytes (dbfd
,
10245 dwp_htab
->section_pool
.v2
.sizes
10246 + (((unit_index
- 1) * dwp_htab
->nr_columns
10248 * sizeof (uint32_t)));
10250 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
10253 case DW_SECT_TYPES
:
10254 sections
.info_or_types_offset
= offset
;
10255 sections
.info_or_types_size
= size
;
10257 case DW_SECT_ABBREV
:
10258 sections
.abbrev_offset
= offset
;
10259 sections
.abbrev_size
= size
;
10262 sections
.line_offset
= offset
;
10263 sections
.line_size
= size
;
10266 sections
.loc_offset
= offset
;
10267 sections
.loc_size
= size
;
10269 case DW_SECT_STR_OFFSETS
:
10270 sections
.str_offsets_offset
= offset
;
10271 sections
.str_offsets_size
= size
;
10273 case DW_SECT_MACINFO
:
10274 sections
.macinfo_offset
= offset
;
10275 sections
.macinfo_size
= size
;
10277 case DW_SECT_MACRO
:
10278 sections
.macro_offset
= offset
;
10279 sections
.macro_size
= size
;
10284 /* It's easier for the rest of the code if we fake a struct dwo_file and
10285 have dwo_unit "live" in that. At least for now.
10287 The DWP file can be made up of a random collection of CUs and TUs.
10288 However, for each CU + set of TUs that came from the same original DWO
10289 file, we can combine them back into a virtual DWO file to save space
10290 (fewer struct dwo_file objects to allocate). Remember that for really
10291 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10294 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10295 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
10296 (long) (sections
.line_size
? sections
.line_offset
: 0),
10297 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
10298 (long) (sections
.str_offsets_size
10299 ? sections
.str_offsets_offset
: 0));
10300 make_cleanup (xfree
, virtual_dwo_name
);
10301 /* Can we use an existing virtual DWO file? */
10302 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10303 /* Create one if necessary. */
10304 if (*dwo_file_slot
== NULL
)
10306 if (dwarf_read_debug
)
10308 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10311 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10312 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
10314 strlen (virtual_dwo_name
));
10315 dwo_file
->comp_dir
= comp_dir
;
10316 dwo_file
->sections
.abbrev
=
10317 create_dwp_v2_section (&dwp_file
->sections
.abbrev
,
10318 sections
.abbrev_offset
, sections
.abbrev_size
);
10319 dwo_file
->sections
.line
=
10320 create_dwp_v2_section (&dwp_file
->sections
.line
,
10321 sections
.line_offset
, sections
.line_size
);
10322 dwo_file
->sections
.loc
=
10323 create_dwp_v2_section (&dwp_file
->sections
.loc
,
10324 sections
.loc_offset
, sections
.loc_size
);
10325 dwo_file
->sections
.macinfo
=
10326 create_dwp_v2_section (&dwp_file
->sections
.macinfo
,
10327 sections
.macinfo_offset
, sections
.macinfo_size
);
10328 dwo_file
->sections
.macro
=
10329 create_dwp_v2_section (&dwp_file
->sections
.macro
,
10330 sections
.macro_offset
, sections
.macro_size
);
10331 dwo_file
->sections
.str_offsets
=
10332 create_dwp_v2_section (&dwp_file
->sections
.str_offsets
,
10333 sections
.str_offsets_offset
,
10334 sections
.str_offsets_size
);
10335 /* The "str" section is global to the entire DWP file. */
10336 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10337 /* The info or types section is assigned below to dwo_unit,
10338 there's no need to record it in dwo_file.
10339 Also, we can't simply record type sections in dwo_file because
10340 we record a pointer into the vector in dwo_unit. As we collect more
10341 types we'll grow the vector and eventually have to reallocate space
10342 for it, invalidating all copies of pointers into the previous
10344 *dwo_file_slot
= dwo_file
;
10348 if (dwarf_read_debug
)
10350 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10353 dwo_file
= *dwo_file_slot
;
10355 do_cleanups (cleanups
);
10357 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10358 dwo_unit
->dwo_file
= dwo_file
;
10359 dwo_unit
->signature
= signature
;
10360 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
10361 sizeof (struct dwarf2_section_info
));
10362 *dwo_unit
->section
= create_dwp_v2_section (is_debug_types
10363 ? &dwp_file
->sections
.types
10364 : &dwp_file
->sections
.info
,
10365 sections
.info_or_types_offset
,
10366 sections
.info_or_types_size
);
10367 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10372 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10373 Returns NULL if the signature isn't found. */
10375 static struct dwo_unit
*
10376 lookup_dwo_unit_in_dwp (struct dwp_file
*dwp_file
, const char *comp_dir
,
10377 ULONGEST signature
, int is_debug_types
)
10379 const struct dwp_hash_table
*dwp_htab
=
10380 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10381 bfd
*dbfd
= dwp_file
->dbfd
;
10382 uint32_t mask
= dwp_htab
->nr_slots
- 1;
10383 uint32_t hash
= signature
& mask
;
10384 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
10387 struct dwo_unit find_dwo_cu
, *dwo_cu
;
10389 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
10390 find_dwo_cu
.signature
= signature
;
10391 slot
= htab_find_slot (is_debug_types
10392 ? dwp_file
->loaded_tus
10393 : dwp_file
->loaded_cus
,
10394 &find_dwo_cu
, INSERT
);
10399 /* Use a for loop so that we don't loop forever on bad debug info. */
10400 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
10402 ULONGEST signature_in_table
;
10404 signature_in_table
=
10405 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
10406 if (signature_in_table
== signature
)
10408 uint32_t unit_index
=
10409 read_4_bytes (dbfd
,
10410 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
10412 if (dwp_file
->version
== 1)
10414 *slot
= create_dwo_unit_in_dwp_v1 (dwp_file
, unit_index
,
10415 comp_dir
, signature
,
10420 *slot
= create_dwo_unit_in_dwp_v2 (dwp_file
, unit_index
,
10421 comp_dir
, signature
,
10426 if (signature_in_table
== 0)
10428 hash
= (hash
+ hash2
) & mask
;
10431 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10432 " [in module %s]"),
10436 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10437 Open the file specified by FILE_NAME and hand it off to BFD for
10438 preliminary analysis. Return a newly initialized bfd *, which
10439 includes a canonicalized copy of FILE_NAME.
10440 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10441 SEARCH_CWD is true if the current directory is to be searched.
10442 It will be searched before debug-file-directory.
10443 If successful, the file is added to the bfd include table of the
10444 objfile's bfd (see gdb_bfd_record_inclusion).
10445 If unable to find/open the file, return NULL.
10446 NOTE: This function is derived from symfile_bfd_open. */
10449 try_open_dwop_file (const char *file_name
, int is_dwp
, int search_cwd
)
10453 char *absolute_name
;
10454 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10455 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10456 to debug_file_directory. */
10458 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
10462 if (*debug_file_directory
!= '\0')
10463 search_path
= concat (".", dirname_separator_string
,
10464 debug_file_directory
, NULL
);
10466 search_path
= xstrdup (".");
10469 search_path
= xstrdup (debug_file_directory
);
10471 flags
= OPF_RETURN_REALPATH
;
10473 flags
|= OPF_SEARCH_IN_PATH
;
10474 desc
= openp (search_path
, flags
, file_name
,
10475 O_RDONLY
| O_BINARY
, &absolute_name
);
10476 xfree (search_path
);
10480 sym_bfd
= gdb_bfd_open (absolute_name
, gnutarget
, desc
);
10481 xfree (absolute_name
);
10482 if (sym_bfd
== NULL
)
10484 bfd_set_cacheable (sym_bfd
, 1);
10486 if (!bfd_check_format (sym_bfd
, bfd_object
))
10488 gdb_bfd_unref (sym_bfd
); /* This also closes desc. */
10492 /* Success. Record the bfd as having been included by the objfile's bfd.
10493 This is important because things like demangled_names_hash lives in the
10494 objfile's per_bfd space and may have references to things like symbol
10495 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10496 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
);
10501 /* Try to open DWO file FILE_NAME.
10502 COMP_DIR is the DW_AT_comp_dir attribute.
10503 The result is the bfd handle of the file.
10504 If there is a problem finding or opening the file, return NULL.
10505 Upon success, the canonicalized path of the file is stored in the bfd,
10506 same as symfile_bfd_open. */
10509 open_dwo_file (const char *file_name
, const char *comp_dir
)
10513 if (IS_ABSOLUTE_PATH (file_name
))
10514 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 0 /*search_cwd*/);
10516 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10518 if (comp_dir
!= NULL
)
10520 char *path_to_try
= concat (comp_dir
, SLASH_STRING
, file_name
, NULL
);
10522 /* NOTE: If comp_dir is a relative path, this will also try the
10523 search path, which seems useful. */
10524 abfd
= try_open_dwop_file (path_to_try
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10525 xfree (path_to_try
);
10530 /* That didn't work, try debug-file-directory, which, despite its name,
10531 is a list of paths. */
10533 if (*debug_file_directory
== '\0')
10536 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10539 /* This function is mapped across the sections and remembers the offset and
10540 size of each of the DWO debugging sections we are interested in. */
10543 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
10545 struct dwo_sections
*dwo_sections
= dwo_sections_ptr
;
10546 const struct dwop_section_names
*names
= &dwop_section_names
;
10548 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10550 dwo_sections
->abbrev
.s
.asection
= sectp
;
10551 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
10553 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10555 dwo_sections
->info
.s
.asection
= sectp
;
10556 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
10558 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10560 dwo_sections
->line
.s
.asection
= sectp
;
10561 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
10563 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10565 dwo_sections
->loc
.s
.asection
= sectp
;
10566 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
10568 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10570 dwo_sections
->macinfo
.s
.asection
= sectp
;
10571 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
10573 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10575 dwo_sections
->macro
.s
.asection
= sectp
;
10576 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
10578 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
10580 dwo_sections
->str
.s
.asection
= sectp
;
10581 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
10583 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10585 dwo_sections
->str_offsets
.s
.asection
= sectp
;
10586 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
10588 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10590 struct dwarf2_section_info type_section
;
10592 memset (&type_section
, 0, sizeof (type_section
));
10593 type_section
.s
.asection
= sectp
;
10594 type_section
.size
= bfd_get_section_size (sectp
);
10595 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
10600 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10601 by PER_CU. This is for the non-DWP case.
10602 The result is NULL if DWO_NAME can't be found. */
10604 static struct dwo_file
*
10605 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
10606 const char *dwo_name
, const char *comp_dir
)
10608 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10609 struct dwo_file
*dwo_file
;
10611 struct cleanup
*cleanups
;
10613 dbfd
= open_dwo_file (dwo_name
, comp_dir
);
10616 if (dwarf_read_debug
)
10617 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
10620 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10621 dwo_file
->dwo_name
= dwo_name
;
10622 dwo_file
->comp_dir
= comp_dir
;
10623 dwo_file
->dbfd
= dbfd
;
10625 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
10627 bfd_map_over_sections (dbfd
, dwarf2_locate_dwo_sections
, &dwo_file
->sections
);
10629 dwo_file
->cu
= create_dwo_cu (dwo_file
);
10631 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
10632 dwo_file
->sections
.types
);
10634 discard_cleanups (cleanups
);
10636 if (dwarf_read_debug
)
10637 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
10642 /* This function is mapped across the sections and remembers the offset and
10643 size of each of the DWP debugging sections common to version 1 and 2 that
10644 we are interested in. */
10647 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
10648 void *dwp_file_ptr
)
10650 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10651 const struct dwop_section_names
*names
= &dwop_section_names
;
10652 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10654 /* Record the ELF section number for later lookup: this is what the
10655 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10656 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10657 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10659 /* Look for specific sections that we need. */
10660 if (section_is_p (sectp
->name
, &names
->str_dwo
))
10662 dwp_file
->sections
.str
.s
.asection
= sectp
;
10663 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
10665 else if (section_is_p (sectp
->name
, &names
->cu_index
))
10667 dwp_file
->sections
.cu_index
.s
.asection
= sectp
;
10668 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
10670 else if (section_is_p (sectp
->name
, &names
->tu_index
))
10672 dwp_file
->sections
.tu_index
.s
.asection
= sectp
;
10673 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
10677 /* This function is mapped across the sections and remembers the offset and
10678 size of each of the DWP version 2 debugging sections that we are interested
10679 in. This is split into a separate function because we don't know if we
10680 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10683 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
10685 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10686 const struct dwop_section_names
*names
= &dwop_section_names
;
10687 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10689 /* Record the ELF section number for later lookup: this is what the
10690 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10691 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10692 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10694 /* Look for specific sections that we need. */
10695 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10697 dwp_file
->sections
.abbrev
.s
.asection
= sectp
;
10698 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
10700 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10702 dwp_file
->sections
.info
.s
.asection
= sectp
;
10703 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
10705 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10707 dwp_file
->sections
.line
.s
.asection
= sectp
;
10708 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
10710 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10712 dwp_file
->sections
.loc
.s
.asection
= sectp
;
10713 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
10715 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10717 dwp_file
->sections
.macinfo
.s
.asection
= sectp
;
10718 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
10720 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10722 dwp_file
->sections
.macro
.s
.asection
= sectp
;
10723 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
10725 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10727 dwp_file
->sections
.str_offsets
.s
.asection
= sectp
;
10728 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
10730 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10732 dwp_file
->sections
.types
.s
.asection
= sectp
;
10733 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
10737 /* Hash function for dwp_file loaded CUs/TUs. */
10740 hash_dwp_loaded_cutus (const void *item
)
10742 const struct dwo_unit
*dwo_unit
= item
;
10744 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10745 return dwo_unit
->signature
;
10748 /* Equality function for dwp_file loaded CUs/TUs. */
10751 eq_dwp_loaded_cutus (const void *a
, const void *b
)
10753 const struct dwo_unit
*dua
= a
;
10754 const struct dwo_unit
*dub
= b
;
10756 return dua
->signature
== dub
->signature
;
10759 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10762 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
10764 return htab_create_alloc_ex (3,
10765 hash_dwp_loaded_cutus
,
10766 eq_dwp_loaded_cutus
,
10768 &objfile
->objfile_obstack
,
10769 hashtab_obstack_allocate
,
10770 dummy_obstack_deallocate
);
10773 /* Try to open DWP file FILE_NAME.
10774 The result is the bfd handle of the file.
10775 If there is a problem finding or opening the file, return NULL.
10776 Upon success, the canonicalized path of the file is stored in the bfd,
10777 same as symfile_bfd_open. */
10780 open_dwp_file (const char *file_name
)
10784 abfd
= try_open_dwop_file (file_name
, 1 /*is_dwp*/, 1 /*search_cwd*/);
10788 /* Work around upstream bug 15652.
10789 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10790 [Whether that's a "bug" is debatable, but it is getting in our way.]
10791 We have no real idea where the dwp file is, because gdb's realpath-ing
10792 of the executable's path may have discarded the needed info.
10793 [IWBN if the dwp file name was recorded in the executable, akin to
10794 .gnu_debuglink, but that doesn't exist yet.]
10795 Strip the directory from FILE_NAME and search again. */
10796 if (*debug_file_directory
!= '\0')
10798 /* Don't implicitly search the current directory here.
10799 If the user wants to search "." to handle this case,
10800 it must be added to debug-file-directory. */
10801 return try_open_dwop_file (lbasename (file_name
), 1 /*is_dwp*/,
10808 /* Initialize the use of the DWP file for the current objfile.
10809 By convention the name of the DWP file is ${objfile}.dwp.
10810 The result is NULL if it can't be found. */
10812 static struct dwp_file
*
10813 open_and_init_dwp_file (void)
10815 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10816 struct dwp_file
*dwp_file
;
10819 struct cleanup
*cleanups
;
10821 /* Try to find first .dwp for the binary file before any symbolic links
10823 dwp_name
= xstrprintf ("%s.dwp", objfile
->original_name
);
10824 cleanups
= make_cleanup (xfree
, dwp_name
);
10826 dbfd
= open_dwp_file (dwp_name
);
10828 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
10830 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10831 dwp_name
= xstrprintf ("%s.dwp", objfile_name (objfile
));
10832 make_cleanup (xfree
, dwp_name
);
10833 dbfd
= open_dwp_file (dwp_name
);
10838 if (dwarf_read_debug
)
10839 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
);
10840 do_cleanups (cleanups
);
10843 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
10844 dwp_file
->name
= bfd_get_filename (dbfd
);
10845 dwp_file
->dbfd
= dbfd
;
10846 do_cleanups (cleanups
);
10848 /* +1: section 0 is unused */
10849 dwp_file
->num_sections
= bfd_count_sections (dbfd
) + 1;
10850 dwp_file
->elf_sections
=
10851 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
10852 dwp_file
->num_sections
, asection
*);
10854 bfd_map_over_sections (dbfd
, dwarf2_locate_common_dwp_sections
, dwp_file
);
10856 dwp_file
->cus
= create_dwp_hash_table (dwp_file
, 0);
10858 dwp_file
->tus
= create_dwp_hash_table (dwp_file
, 1);
10860 /* The DWP file version is stored in the hash table. Oh well. */
10861 if (dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
10863 /* Technically speaking, we should try to limp along, but this is
10864 pretty bizarre. We use pulongest here because that's the established
10865 portability solution (e.g, we cannot use %u for uint32_t). */
10866 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10867 " TU version %s [in DWP file %s]"),
10868 pulongest (dwp_file
->cus
->version
),
10869 pulongest (dwp_file
->tus
->version
), dwp_name
);
10871 dwp_file
->version
= dwp_file
->cus
->version
;
10873 if (dwp_file
->version
== 2)
10874 bfd_map_over_sections (dbfd
, dwarf2_locate_v2_dwp_sections
, dwp_file
);
10876 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
10877 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
10879 if (dwarf_read_debug
)
10881 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
10882 fprintf_unfiltered (gdb_stdlog
,
10883 " %s CUs, %s TUs\n",
10884 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
10885 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
10891 /* Wrapper around open_and_init_dwp_file, only open it once. */
10893 static struct dwp_file
*
10894 get_dwp_file (void)
10896 if (! dwarf2_per_objfile
->dwp_checked
)
10898 dwarf2_per_objfile
->dwp_file
= open_and_init_dwp_file ();
10899 dwarf2_per_objfile
->dwp_checked
= 1;
10901 return dwarf2_per_objfile
->dwp_file
;
10904 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10905 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10906 or in the DWP file for the objfile, referenced by THIS_UNIT.
10907 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10908 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10910 This is called, for example, when wanting to read a variable with a
10911 complex location. Therefore we don't want to do file i/o for every call.
10912 Therefore we don't want to look for a DWO file on every call.
10913 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10914 then we check if we've already seen DWO_NAME, and only THEN do we check
10917 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10918 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10920 static struct dwo_unit
*
10921 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
10922 const char *dwo_name
, const char *comp_dir
,
10923 ULONGEST signature
, int is_debug_types
)
10925 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10926 const char *kind
= is_debug_types
? "TU" : "CU";
10927 void **dwo_file_slot
;
10928 struct dwo_file
*dwo_file
;
10929 struct dwp_file
*dwp_file
;
10931 /* First see if there's a DWP file.
10932 If we have a DWP file but didn't find the DWO inside it, don't
10933 look for the original DWO file. It makes gdb behave differently
10934 depending on whether one is debugging in the build tree. */
10936 dwp_file
= get_dwp_file ();
10937 if (dwp_file
!= NULL
)
10939 const struct dwp_hash_table
*dwp_htab
=
10940 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10942 if (dwp_htab
!= NULL
)
10944 struct dwo_unit
*dwo_cutu
=
10945 lookup_dwo_unit_in_dwp (dwp_file
, comp_dir
,
10946 signature
, is_debug_types
);
10948 if (dwo_cutu
!= NULL
)
10950 if (dwarf_read_debug
)
10952 fprintf_unfiltered (gdb_stdlog
,
10953 "Virtual DWO %s %s found: @%s\n",
10954 kind
, hex_string (signature
),
10955 host_address_to_string (dwo_cutu
));
10963 /* No DWP file, look for the DWO file. */
10965 dwo_file_slot
= lookup_dwo_file_slot (dwo_name
, comp_dir
);
10966 if (*dwo_file_slot
== NULL
)
10968 /* Read in the file and build a table of the CUs/TUs it contains. */
10969 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
10971 /* NOTE: This will be NULL if unable to open the file. */
10972 dwo_file
= *dwo_file_slot
;
10974 if (dwo_file
!= NULL
)
10976 struct dwo_unit
*dwo_cutu
= NULL
;
10978 if (is_debug_types
&& dwo_file
->tus
)
10980 struct dwo_unit find_dwo_cutu
;
10982 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
10983 find_dwo_cutu
.signature
= signature
;
10984 dwo_cutu
= htab_find (dwo_file
->tus
, &find_dwo_cutu
);
10986 else if (!is_debug_types
&& dwo_file
->cu
)
10988 if (signature
== dwo_file
->cu
->signature
)
10989 dwo_cutu
= dwo_file
->cu
;
10992 if (dwo_cutu
!= NULL
)
10994 if (dwarf_read_debug
)
10996 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
10997 kind
, dwo_name
, hex_string (signature
),
10998 host_address_to_string (dwo_cutu
));
11005 /* We didn't find it. This could mean a dwo_id mismatch, or
11006 someone deleted the DWO/DWP file, or the search path isn't set up
11007 correctly to find the file. */
11009 if (dwarf_read_debug
)
11011 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
11012 kind
, dwo_name
, hex_string (signature
));
11015 /* This is a warning and not a complaint because it can be caused by
11016 pilot error (e.g., user accidentally deleting the DWO). */
11018 /* Print the name of the DWP file if we looked there, helps the user
11019 better diagnose the problem. */
11020 char *dwp_text
= NULL
;
11021 struct cleanup
*cleanups
;
11023 if (dwp_file
!= NULL
)
11024 dwp_text
= xstrprintf (" [in DWP file %s]", lbasename (dwp_file
->name
));
11025 cleanups
= make_cleanup (xfree
, dwp_text
);
11027 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
11028 " [in module %s]"),
11029 kind
, dwo_name
, hex_string (signature
),
11030 dwp_text
!= NULL
? dwp_text
: "",
11031 this_unit
->is_debug_types
? "TU" : "CU",
11032 this_unit
->offset
.sect_off
, objfile_name (objfile
));
11034 do_cleanups (cleanups
);
11039 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
11040 See lookup_dwo_cutu_unit for details. */
11042 static struct dwo_unit
*
11043 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
11044 const char *dwo_name
, const char *comp_dir
,
11045 ULONGEST signature
)
11047 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
11050 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
11051 See lookup_dwo_cutu_unit for details. */
11053 static struct dwo_unit
*
11054 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
11055 const char *dwo_name
, const char *comp_dir
)
11057 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
11060 /* Traversal function for queue_and_load_all_dwo_tus. */
11063 queue_and_load_dwo_tu (void **slot
, void *info
)
11065 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
11066 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
11067 ULONGEST signature
= dwo_unit
->signature
;
11068 struct signatured_type
*sig_type
=
11069 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
11071 if (sig_type
!= NULL
)
11073 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
11075 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
11076 a real dependency of PER_CU on SIG_TYPE. That is detected later
11077 while processing PER_CU. */
11078 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
11079 load_full_type_unit (sig_cu
);
11080 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
11086 /* Queue all TUs contained in the DWO of PER_CU to be read in.
11087 The DWO may have the only definition of the type, though it may not be
11088 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
11089 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
11092 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
11094 struct dwo_unit
*dwo_unit
;
11095 struct dwo_file
*dwo_file
;
11097 gdb_assert (!per_cu
->is_debug_types
);
11098 gdb_assert (get_dwp_file () == NULL
);
11099 gdb_assert (per_cu
->cu
!= NULL
);
11101 dwo_unit
= per_cu
->cu
->dwo_unit
;
11102 gdb_assert (dwo_unit
!= NULL
);
11104 dwo_file
= dwo_unit
->dwo_file
;
11105 if (dwo_file
->tus
!= NULL
)
11106 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
11109 /* Free all resources associated with DWO_FILE.
11110 Close the DWO file and munmap the sections.
11111 All memory should be on the objfile obstack. */
11114 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
11117 struct dwarf2_section_info
*section
;
11119 /* Note: dbfd is NULL for virtual DWO files. */
11120 gdb_bfd_unref (dwo_file
->dbfd
);
11122 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
11125 /* Wrapper for free_dwo_file for use in cleanups. */
11128 free_dwo_file_cleanup (void *arg
)
11130 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
11131 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11133 free_dwo_file (dwo_file
, objfile
);
11136 /* Traversal function for free_dwo_files. */
11139 free_dwo_file_from_slot (void **slot
, void *info
)
11141 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
11142 struct objfile
*objfile
= (struct objfile
*) info
;
11144 free_dwo_file (dwo_file
, objfile
);
11149 /* Free all resources associated with DWO_FILES. */
11152 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
11154 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
11157 /* Read in various DIEs. */
11159 /* qsort helper for inherit_abstract_dies. */
11162 unsigned_int_compar (const void *ap
, const void *bp
)
11164 unsigned int a
= *(unsigned int *) ap
;
11165 unsigned int b
= *(unsigned int *) bp
;
11167 return (a
> b
) - (b
> a
);
11170 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
11171 Inherit only the children of the DW_AT_abstract_origin DIE not being
11172 already referenced by DW_AT_abstract_origin from the children of the
11176 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
11178 struct die_info
*child_die
;
11179 unsigned die_children_count
;
11180 /* CU offsets which were referenced by children of the current DIE. */
11181 sect_offset
*offsets
;
11182 sect_offset
*offsets_end
, *offsetp
;
11183 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
11184 struct die_info
*origin_die
;
11185 /* Iterator of the ORIGIN_DIE children. */
11186 struct die_info
*origin_child_die
;
11187 struct cleanup
*cleanups
;
11188 struct attribute
*attr
;
11189 struct dwarf2_cu
*origin_cu
;
11190 struct pending
**origin_previous_list_in_scope
;
11192 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11196 /* Note that following die references may follow to a die in a
11200 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
11202 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
11204 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
11205 origin_cu
->list_in_scope
= cu
->list_in_scope
;
11207 if (die
->tag
!= origin_die
->tag
11208 && !(die
->tag
== DW_TAG_inlined_subroutine
11209 && origin_die
->tag
== DW_TAG_subprogram
))
11210 complaint (&symfile_complaints
,
11211 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
11212 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
11214 child_die
= die
->child
;
11215 die_children_count
= 0;
11216 while (child_die
&& child_die
->tag
)
11218 child_die
= sibling_die (child_die
);
11219 die_children_count
++;
11221 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
11222 cleanups
= make_cleanup (xfree
, offsets
);
11224 offsets_end
= offsets
;
11225 for (child_die
= die
->child
;
11226 child_die
&& child_die
->tag
;
11227 child_die
= sibling_die (child_die
))
11229 struct die_info
*child_origin_die
;
11230 struct dwarf2_cu
*child_origin_cu
;
11232 /* We are trying to process concrete instance entries:
11233 DW_TAG_GNU_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
11234 it's not relevant to our analysis here. i.e. detecting DIEs that are
11235 present in the abstract instance but not referenced in the concrete
11237 if (child_die
->tag
== DW_TAG_GNU_call_site
)
11240 /* For each CHILD_DIE, find the corresponding child of
11241 ORIGIN_DIE. If there is more than one layer of
11242 DW_AT_abstract_origin, follow them all; there shouldn't be,
11243 but GCC versions at least through 4.4 generate this (GCC PR
11245 child_origin_die
= child_die
;
11246 child_origin_cu
= cu
;
11249 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
11253 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
11257 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
11258 counterpart may exist. */
11259 if (child_origin_die
!= child_die
)
11261 if (child_die
->tag
!= child_origin_die
->tag
11262 && !(child_die
->tag
== DW_TAG_inlined_subroutine
11263 && child_origin_die
->tag
== DW_TAG_subprogram
))
11264 complaint (&symfile_complaints
,
11265 _("Child DIE 0x%x and its abstract origin 0x%x have "
11266 "different tags"), child_die
->offset
.sect_off
,
11267 child_origin_die
->offset
.sect_off
);
11268 if (child_origin_die
->parent
!= origin_die
)
11269 complaint (&symfile_complaints
,
11270 _("Child DIE 0x%x and its abstract origin 0x%x have "
11271 "different parents"), child_die
->offset
.sect_off
,
11272 child_origin_die
->offset
.sect_off
);
11274 *offsets_end
++ = child_origin_die
->offset
;
11277 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
11278 unsigned_int_compar
);
11279 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
11280 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
11281 complaint (&symfile_complaints
,
11282 _("Multiple children of DIE 0x%x refer "
11283 "to DIE 0x%x as their abstract origin"),
11284 die
->offset
.sect_off
, offsetp
->sect_off
);
11287 origin_child_die
= origin_die
->child
;
11288 while (origin_child_die
&& origin_child_die
->tag
)
11290 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11291 while (offsetp
< offsets_end
11292 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
11294 if (offsetp
>= offsets_end
11295 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
11297 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11298 Check whether we're already processing ORIGIN_CHILD_DIE.
11299 This can happen with mutually referenced abstract_origins.
11301 if (!origin_child_die
->in_process
)
11302 process_die (origin_child_die
, origin_cu
);
11304 origin_child_die
= sibling_die (origin_child_die
);
11306 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
11308 do_cleanups (cleanups
);
11312 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11314 struct objfile
*objfile
= cu
->objfile
;
11315 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11316 struct context_stack
*newobj
;
11319 struct die_info
*child_die
;
11320 struct attribute
*attr
, *call_line
, *call_file
;
11322 CORE_ADDR baseaddr
;
11323 struct block
*block
;
11324 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11325 VEC (symbolp
) *template_args
= NULL
;
11326 struct template_symbol
*templ_func
= NULL
;
11330 /* If we do not have call site information, we can't show the
11331 caller of this inlined function. That's too confusing, so
11332 only use the scope for local variables. */
11333 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
11334 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
11335 if (call_line
== NULL
|| call_file
== NULL
)
11337 read_lexical_block_scope (die
, cu
);
11342 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11344 name
= dwarf2_name (die
, cu
);
11346 /* Ignore functions with missing or empty names. These are actually
11347 illegal according to the DWARF standard. */
11350 complaint (&symfile_complaints
,
11351 _("missing name for subprogram DIE at %d"),
11352 die
->offset
.sect_off
);
11356 /* Ignore functions with missing or invalid low and high pc attributes. */
11357 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11359 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
11360 if (!attr
|| !DW_UNSND (attr
))
11361 complaint (&symfile_complaints
,
11362 _("cannot get low and high bounds "
11363 "for subprogram DIE at %d"),
11364 die
->offset
.sect_off
);
11368 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11369 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11371 /* If we have any template arguments, then we must allocate a
11372 different sort of symbol. */
11373 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
11375 if (child_die
->tag
== DW_TAG_template_type_param
11376 || child_die
->tag
== DW_TAG_template_value_param
)
11378 templ_func
= allocate_template_symbol (objfile
);
11379 templ_func
->base
.is_cplus_template_function
= 1;
11384 newobj
= push_context (0, lowpc
);
11385 newobj
->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
11386 (struct symbol
*) templ_func
);
11388 /* If there is a location expression for DW_AT_frame_base, record
11390 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
11392 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
11394 cu
->list_in_scope
= &local_symbols
;
11396 if (die
->child
!= NULL
)
11398 child_die
= die
->child
;
11399 while (child_die
&& child_die
->tag
)
11401 if (child_die
->tag
== DW_TAG_template_type_param
11402 || child_die
->tag
== DW_TAG_template_value_param
)
11404 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
11407 VEC_safe_push (symbolp
, template_args
, arg
);
11410 process_die (child_die
, cu
);
11411 child_die
= sibling_die (child_die
);
11415 inherit_abstract_dies (die
, cu
);
11417 /* If we have a DW_AT_specification, we might need to import using
11418 directives from the context of the specification DIE. See the
11419 comment in determine_prefix. */
11420 if (cu
->language
== language_cplus
11421 && dwarf2_attr (die
, DW_AT_specification
, cu
))
11423 struct dwarf2_cu
*spec_cu
= cu
;
11424 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
11428 child_die
= spec_die
->child
;
11429 while (child_die
&& child_die
->tag
)
11431 if (child_die
->tag
== DW_TAG_imported_module
)
11432 process_die (child_die
, spec_cu
);
11433 child_die
= sibling_die (child_die
);
11436 /* In some cases, GCC generates specification DIEs that
11437 themselves contain DW_AT_specification attributes. */
11438 spec_die
= die_specification (spec_die
, &spec_cu
);
11442 newobj
= pop_context ();
11443 /* Make a block for the local symbols within. */
11444 block
= finish_block (newobj
->name
, &local_symbols
, newobj
->old_blocks
,
11447 /* For C++, set the block's scope. */
11448 if ((cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
11449 && cu
->processing_has_namespace_info
)
11450 block_set_scope (block
, determine_prefix (die
, cu
),
11451 &objfile
->objfile_obstack
);
11453 /* If we have address ranges, record them. */
11454 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11456 gdbarch_make_symbol_special (gdbarch
, newobj
->name
, objfile
);
11458 /* Attach template arguments to function. */
11459 if (! VEC_empty (symbolp
, template_args
))
11461 gdb_assert (templ_func
!= NULL
);
11463 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
11464 templ_func
->template_arguments
11465 = obstack_alloc (&objfile
->objfile_obstack
,
11466 (templ_func
->n_template_arguments
11467 * sizeof (struct symbol
*)));
11468 memcpy (templ_func
->template_arguments
,
11469 VEC_address (symbolp
, template_args
),
11470 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
11471 VEC_free (symbolp
, template_args
);
11474 /* In C++, we can have functions nested inside functions (e.g., when
11475 a function declares a class that has methods). This means that
11476 when we finish processing a function scope, we may need to go
11477 back to building a containing block's symbol lists. */
11478 local_symbols
= newobj
->locals
;
11479 using_directives
= newobj
->using_directives
;
11481 /* If we've finished processing a top-level function, subsequent
11482 symbols go in the file symbol list. */
11483 if (outermost_context_p ())
11484 cu
->list_in_scope
= &file_symbols
;
11487 /* Process all the DIES contained within a lexical block scope. Start
11488 a new scope, process the dies, and then close the scope. */
11491 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11493 struct objfile
*objfile
= cu
->objfile
;
11494 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11495 struct context_stack
*newobj
;
11496 CORE_ADDR lowpc
, highpc
;
11497 struct die_info
*child_die
;
11498 CORE_ADDR baseaddr
;
11500 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11502 /* Ignore blocks with missing or invalid low and high pc attributes. */
11503 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11504 as multiple lexical blocks? Handling children in a sane way would
11505 be nasty. Might be easier to properly extend generic blocks to
11506 describe ranges. */
11507 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11509 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11510 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11512 push_context (0, lowpc
);
11513 if (die
->child
!= NULL
)
11515 child_die
= die
->child
;
11516 while (child_die
&& child_die
->tag
)
11518 process_die (child_die
, cu
);
11519 child_die
= sibling_die (child_die
);
11522 inherit_abstract_dies (die
, cu
);
11523 newobj
= pop_context ();
11525 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
11527 struct block
*block
11528 = finish_block (0, &local_symbols
, newobj
->old_blocks
,
11529 newobj
->start_addr
, highpc
);
11531 /* Note that recording ranges after traversing children, as we
11532 do here, means that recording a parent's ranges entails
11533 walking across all its children's ranges as they appear in
11534 the address map, which is quadratic behavior.
11536 It would be nicer to record the parent's ranges before
11537 traversing its children, simply overriding whatever you find
11538 there. But since we don't even decide whether to create a
11539 block until after we've traversed its children, that's hard
11541 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11543 local_symbols
= newobj
->locals
;
11544 using_directives
= newobj
->using_directives
;
11547 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11550 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11552 struct objfile
*objfile
= cu
->objfile
;
11553 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11554 CORE_ADDR pc
, baseaddr
;
11555 struct attribute
*attr
;
11556 struct call_site
*call_site
, call_site_local
;
11559 struct die_info
*child_die
;
11561 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11563 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11566 complaint (&symfile_complaints
,
11567 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11568 "DIE 0x%x [in module %s]"),
11569 die
->offset
.sect_off
, objfile_name (objfile
));
11572 pc
= attr_value_as_address (attr
) + baseaddr
;
11573 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
11575 if (cu
->call_site_htab
== NULL
)
11576 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
11577 NULL
, &objfile
->objfile_obstack
,
11578 hashtab_obstack_allocate
, NULL
);
11579 call_site_local
.pc
= pc
;
11580 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
11583 complaint (&symfile_complaints
,
11584 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11585 "DIE 0x%x [in module %s]"),
11586 paddress (gdbarch
, pc
), die
->offset
.sect_off
,
11587 objfile_name (objfile
));
11591 /* Count parameters at the caller. */
11594 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11595 child_die
= sibling_die (child_die
))
11597 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11599 complaint (&symfile_complaints
,
11600 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11601 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11602 child_die
->tag
, child_die
->offset
.sect_off
,
11603 objfile_name (objfile
));
11610 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
11611 (sizeof (*call_site
)
11612 + (sizeof (*call_site
->parameter
)
11613 * (nparams
- 1))));
11615 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
11616 call_site
->pc
= pc
;
11618 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
11620 struct die_info
*func_die
;
11622 /* Skip also over DW_TAG_inlined_subroutine. */
11623 for (func_die
= die
->parent
;
11624 func_die
&& func_die
->tag
!= DW_TAG_subprogram
11625 && func_die
->tag
!= DW_TAG_subroutine_type
;
11626 func_die
= func_die
->parent
);
11628 /* DW_AT_GNU_all_call_sites is a superset
11629 of DW_AT_GNU_all_tail_call_sites. */
11631 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
11632 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
11634 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11635 not complete. But keep CALL_SITE for look ups via call_site_htab,
11636 both the initial caller containing the real return address PC and
11637 the final callee containing the current PC of a chain of tail
11638 calls do not need to have the tail call list complete. But any
11639 function candidate for a virtual tail call frame searched via
11640 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11641 determined unambiguously. */
11645 struct type
*func_type
= NULL
;
11648 func_type
= get_die_type (func_die
, cu
);
11649 if (func_type
!= NULL
)
11651 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
11653 /* Enlist this call site to the function. */
11654 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
11655 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
11658 complaint (&symfile_complaints
,
11659 _("Cannot find function owning DW_TAG_GNU_call_site "
11660 "DIE 0x%x [in module %s]"),
11661 die
->offset
.sect_off
, objfile_name (objfile
));
11665 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
11667 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11668 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
11669 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
11670 /* Keep NULL DWARF_BLOCK. */;
11671 else if (attr_form_is_block (attr
))
11673 struct dwarf2_locexpr_baton
*dlbaton
;
11675 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
11676 dlbaton
->data
= DW_BLOCK (attr
)->data
;
11677 dlbaton
->size
= DW_BLOCK (attr
)->size
;
11678 dlbaton
->per_cu
= cu
->per_cu
;
11680 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
11682 else if (attr_form_is_ref (attr
))
11684 struct dwarf2_cu
*target_cu
= cu
;
11685 struct die_info
*target_die
;
11687 target_die
= follow_die_ref (die
, attr
, &target_cu
);
11688 gdb_assert (target_cu
->objfile
== objfile
);
11689 if (die_is_declaration (target_die
, target_cu
))
11691 const char *target_physname
= NULL
;
11692 struct attribute
*target_attr
;
11694 /* Prefer the mangled name; otherwise compute the demangled one. */
11695 target_attr
= dwarf2_attr (target_die
, DW_AT_linkage_name
, target_cu
);
11696 if (target_attr
== NULL
)
11697 target_attr
= dwarf2_attr (target_die
, DW_AT_MIPS_linkage_name
,
11699 if (target_attr
!= NULL
&& DW_STRING (target_attr
) != NULL
)
11700 target_physname
= DW_STRING (target_attr
);
11702 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
11703 if (target_physname
== NULL
)
11704 complaint (&symfile_complaints
,
11705 _("DW_AT_GNU_call_site_target target DIE has invalid "
11706 "physname, for referencing DIE 0x%x [in module %s]"),
11707 die
->offset
.sect_off
, objfile_name (objfile
));
11709 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
11715 /* DW_AT_entry_pc should be preferred. */
11716 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
11717 complaint (&symfile_complaints
,
11718 _("DW_AT_GNU_call_site_target target DIE has invalid "
11719 "low pc, for referencing DIE 0x%x [in module %s]"),
11720 die
->offset
.sect_off
, objfile_name (objfile
));
11723 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11724 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
11729 complaint (&symfile_complaints
,
11730 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11731 "block nor reference, for DIE 0x%x [in module %s]"),
11732 die
->offset
.sect_off
, objfile_name (objfile
));
11734 call_site
->per_cu
= cu
->per_cu
;
11736 for (child_die
= die
->child
;
11737 child_die
&& child_die
->tag
;
11738 child_die
= sibling_die (child_die
))
11740 struct call_site_parameter
*parameter
;
11741 struct attribute
*loc
, *origin
;
11743 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11745 /* Already printed the complaint above. */
11749 gdb_assert (call_site
->parameter_count
< nparams
);
11750 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
11752 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11753 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11754 register is contained in DW_AT_GNU_call_site_value. */
11756 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
11757 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
11758 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
11760 sect_offset offset
;
11762 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
11763 offset
= dwarf2_get_ref_die_offset (origin
);
11764 if (!offset_in_cu_p (&cu
->header
, offset
))
11766 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11767 binding can be done only inside one CU. Such referenced DIE
11768 therefore cannot be even moved to DW_TAG_partial_unit. */
11769 complaint (&symfile_complaints
,
11770 _("DW_AT_abstract_origin offset is not in CU for "
11771 "DW_TAG_GNU_call_site child DIE 0x%x "
11773 child_die
->offset
.sect_off
, objfile_name (objfile
));
11776 parameter
->u
.param_offset
.cu_off
= (offset
.sect_off
11777 - cu
->header
.offset
.sect_off
);
11779 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
11781 complaint (&symfile_complaints
,
11782 _("No DW_FORM_block* DW_AT_location for "
11783 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11784 child_die
->offset
.sect_off
, objfile_name (objfile
));
11789 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
11790 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
11791 if (parameter
->u
.dwarf_reg
!= -1)
11792 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
11793 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
11794 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
11795 ¶meter
->u
.fb_offset
))
11796 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
11799 complaint (&symfile_complaints
,
11800 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11801 "for DW_FORM_block* DW_AT_location is supported for "
11802 "DW_TAG_GNU_call_site child DIE 0x%x "
11804 child_die
->offset
.sect_off
, objfile_name (objfile
));
11809 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
11810 if (!attr_form_is_block (attr
))
11812 complaint (&symfile_complaints
,
11813 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11814 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11815 child_die
->offset
.sect_off
, objfile_name (objfile
));
11818 parameter
->value
= DW_BLOCK (attr
)->data
;
11819 parameter
->value_size
= DW_BLOCK (attr
)->size
;
11821 /* Parameters are not pre-cleared by memset above. */
11822 parameter
->data_value
= NULL
;
11823 parameter
->data_value_size
= 0;
11824 call_site
->parameter_count
++;
11826 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
11829 if (!attr_form_is_block (attr
))
11830 complaint (&symfile_complaints
,
11831 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11832 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11833 child_die
->offset
.sect_off
, objfile_name (objfile
));
11836 parameter
->data_value
= DW_BLOCK (attr
)->data
;
11837 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
11843 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11844 Return 1 if the attributes are present and valid, otherwise, return 0.
11845 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11848 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
11849 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
11850 struct partial_symtab
*ranges_pst
)
11852 struct objfile
*objfile
= cu
->objfile
;
11853 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11854 struct comp_unit_head
*cu_header
= &cu
->header
;
11855 bfd
*obfd
= objfile
->obfd
;
11856 unsigned int addr_size
= cu_header
->addr_size
;
11857 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
11858 /* Base address selection entry. */
11861 unsigned int dummy
;
11862 const gdb_byte
*buffer
;
11866 CORE_ADDR high
= 0;
11867 CORE_ADDR baseaddr
;
11869 found_base
= cu
->base_known
;
11870 base
= cu
->base_address
;
11872 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
11873 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
11875 complaint (&symfile_complaints
,
11876 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11880 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
11882 /* Read in the largest possible address. */
11883 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
11884 if ((marker
& mask
) == mask
)
11886 /* If we found the largest possible address, then
11887 read the base address. */
11888 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11889 buffer
+= 2 * addr_size
;
11890 offset
+= 2 * addr_size
;
11896 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11900 CORE_ADDR range_beginning
, range_end
;
11902 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
11903 buffer
+= addr_size
;
11904 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
11905 buffer
+= addr_size
;
11906 offset
+= 2 * addr_size
;
11908 /* An end of list marker is a pair of zero addresses. */
11909 if (range_beginning
== 0 && range_end
== 0)
11910 /* Found the end of list entry. */
11913 /* Each base address selection entry is a pair of 2 values.
11914 The first is the largest possible address, the second is
11915 the base address. Check for a base address here. */
11916 if ((range_beginning
& mask
) == mask
)
11918 /* If we found the largest possible address, then
11919 read the base address. */
11920 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11927 /* We have no valid base address for the ranges
11929 complaint (&symfile_complaints
,
11930 _("Invalid .debug_ranges data (no base address)"));
11934 if (range_beginning
> range_end
)
11936 /* Inverted range entries are invalid. */
11937 complaint (&symfile_complaints
,
11938 _("Invalid .debug_ranges data (inverted range)"));
11942 /* Empty range entries have no effect. */
11943 if (range_beginning
== range_end
)
11946 range_beginning
+= base
;
11949 /* A not-uncommon case of bad debug info.
11950 Don't pollute the addrmap with bad data. */
11951 if (range_beginning
+ baseaddr
== 0
11952 && !dwarf2_per_objfile
->has_section_at_zero
)
11954 complaint (&symfile_complaints
,
11955 _(".debug_ranges entry has start address of zero"
11956 " [in module %s]"), objfile_name (objfile
));
11960 if (ranges_pst
!= NULL
)
11965 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
11966 range_beginning
+ baseaddr
);
11967 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
11968 range_end
+ baseaddr
);
11969 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
11973 /* FIXME: This is recording everything as a low-high
11974 segment of consecutive addresses. We should have a
11975 data structure for discontiguous block ranges
11979 low
= range_beginning
;
11985 if (range_beginning
< low
)
11986 low
= range_beginning
;
11987 if (range_end
> high
)
11993 /* If the first entry is an end-of-list marker, the range
11994 describes an empty scope, i.e. no instructions. */
12000 *high_return
= high
;
12004 /* Get low and high pc attributes from a die. Return 1 if the attributes
12005 are present and valid, otherwise, return 0. Return -1 if the range is
12006 discontinuous, i.e. derived from DW_AT_ranges information. */
12009 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
12010 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
12011 struct partial_symtab
*pst
)
12013 struct attribute
*attr
;
12014 struct attribute
*attr_high
;
12016 CORE_ADDR high
= 0;
12019 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12022 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12025 low
= attr_value_as_address (attr
);
12026 high
= attr_value_as_address (attr_high
);
12027 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12031 /* Found high w/o low attribute. */
12034 /* Found consecutive range of addresses. */
12039 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12042 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12043 We take advantage of the fact that DW_AT_ranges does not appear
12044 in DW_TAG_compile_unit of DWO files. */
12045 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12046 unsigned int ranges_offset
= (DW_UNSND (attr
)
12047 + (need_ranges_base
12051 /* Value of the DW_AT_ranges attribute is the offset in the
12052 .debug_ranges section. */
12053 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
12055 /* Found discontinuous range of addresses. */
12060 /* read_partial_die has also the strict LOW < HIGH requirement. */
12064 /* When using the GNU linker, .gnu.linkonce. sections are used to
12065 eliminate duplicate copies of functions and vtables and such.
12066 The linker will arbitrarily choose one and discard the others.
12067 The AT_*_pc values for such functions refer to local labels in
12068 these sections. If the section from that file was discarded, the
12069 labels are not in the output, so the relocs get a value of 0.
12070 If this is a discarded function, mark the pc bounds as invalid,
12071 so that GDB will ignore it. */
12072 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12081 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
12082 its low and high PC addresses. Do nothing if these addresses could not
12083 be determined. Otherwise, set LOWPC to the low address if it is smaller,
12084 and HIGHPC to the high address if greater than HIGHPC. */
12087 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
12088 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12089 struct dwarf2_cu
*cu
)
12091 CORE_ADDR low
, high
;
12092 struct die_info
*child
= die
->child
;
12094 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
12096 *lowpc
= min (*lowpc
, low
);
12097 *highpc
= max (*highpc
, high
);
12100 /* If the language does not allow nested subprograms (either inside
12101 subprograms or lexical blocks), we're done. */
12102 if (cu
->language
!= language_ada
)
12105 /* Check all the children of the given DIE. If it contains nested
12106 subprograms, then check their pc bounds. Likewise, we need to
12107 check lexical blocks as well, as they may also contain subprogram
12109 while (child
&& child
->tag
)
12111 if (child
->tag
== DW_TAG_subprogram
12112 || child
->tag
== DW_TAG_lexical_block
)
12113 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
12114 child
= sibling_die (child
);
12118 /* Get the low and high pc's represented by the scope DIE, and store
12119 them in *LOWPC and *HIGHPC. If the correct values can't be
12120 determined, set *LOWPC to -1 and *HIGHPC to 0. */
12123 get_scope_pc_bounds (struct die_info
*die
,
12124 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12125 struct dwarf2_cu
*cu
)
12127 CORE_ADDR best_low
= (CORE_ADDR
) -1;
12128 CORE_ADDR best_high
= (CORE_ADDR
) 0;
12129 CORE_ADDR current_low
, current_high
;
12131 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
12133 best_low
= current_low
;
12134 best_high
= current_high
;
12138 struct die_info
*child
= die
->child
;
12140 while (child
&& child
->tag
)
12142 switch (child
->tag
) {
12143 case DW_TAG_subprogram
:
12144 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
12146 case DW_TAG_namespace
:
12147 case DW_TAG_module
:
12148 /* FIXME: carlton/2004-01-16: Should we do this for
12149 DW_TAG_class_type/DW_TAG_structure_type, too? I think
12150 that current GCC's always emit the DIEs corresponding
12151 to definitions of methods of classes as children of a
12152 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
12153 the DIEs giving the declarations, which could be
12154 anywhere). But I don't see any reason why the
12155 standards says that they have to be there. */
12156 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
12158 if (current_low
!= ((CORE_ADDR
) -1))
12160 best_low
= min (best_low
, current_low
);
12161 best_high
= max (best_high
, current_high
);
12169 child
= sibling_die (child
);
12174 *highpc
= best_high
;
12177 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
12181 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
12182 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
12184 struct objfile
*objfile
= cu
->objfile
;
12185 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12186 struct attribute
*attr
;
12187 struct attribute
*attr_high
;
12189 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12192 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12195 CORE_ADDR low
= attr_value_as_address (attr
);
12196 CORE_ADDR high
= attr_value_as_address (attr_high
);
12198 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12201 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
12202 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
12203 record_block_range (block
, low
, high
- 1);
12207 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12210 bfd
*obfd
= objfile
->obfd
;
12211 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12212 We take advantage of the fact that DW_AT_ranges does not appear
12213 in DW_TAG_compile_unit of DWO files. */
12214 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12216 /* The value of the DW_AT_ranges attribute is the offset of the
12217 address range list in the .debug_ranges section. */
12218 unsigned long offset
= (DW_UNSND (attr
)
12219 + (need_ranges_base
? cu
->ranges_base
: 0));
12220 const gdb_byte
*buffer
;
12222 /* For some target architectures, but not others, the
12223 read_address function sign-extends the addresses it returns.
12224 To recognize base address selection entries, we need a
12226 unsigned int addr_size
= cu
->header
.addr_size
;
12227 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
12229 /* The base address, to which the next pair is relative. Note
12230 that this 'base' is a DWARF concept: most entries in a range
12231 list are relative, to reduce the number of relocs against the
12232 debugging information. This is separate from this function's
12233 'baseaddr' argument, which GDB uses to relocate debugging
12234 information from a shared library based on the address at
12235 which the library was loaded. */
12236 CORE_ADDR base
= cu
->base_address
;
12237 int base_known
= cu
->base_known
;
12239 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
12240 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
12242 complaint (&symfile_complaints
,
12243 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
12247 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
12251 unsigned int bytes_read
;
12252 CORE_ADDR start
, end
;
12254 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12255 buffer
+= bytes_read
;
12256 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12257 buffer
+= bytes_read
;
12259 /* Did we find the end of the range list? */
12260 if (start
== 0 && end
== 0)
12263 /* Did we find a base address selection entry? */
12264 else if ((start
& base_select_mask
) == base_select_mask
)
12270 /* We found an ordinary address range. */
12275 complaint (&symfile_complaints
,
12276 _("Invalid .debug_ranges data "
12277 "(no base address)"));
12283 /* Inverted range entries are invalid. */
12284 complaint (&symfile_complaints
,
12285 _("Invalid .debug_ranges data "
12286 "(inverted range)"));
12290 /* Empty range entries have no effect. */
12294 start
+= base
+ baseaddr
;
12295 end
+= base
+ baseaddr
;
12297 /* A not-uncommon case of bad debug info.
12298 Don't pollute the addrmap with bad data. */
12299 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12301 complaint (&symfile_complaints
,
12302 _(".debug_ranges entry has start address of zero"
12303 " [in module %s]"), objfile_name (objfile
));
12307 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
12308 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
12309 record_block_range (block
, start
, end
- 1);
12315 /* Check whether the producer field indicates either of GCC < 4.6, or the
12316 Intel C/C++ compiler, and cache the result in CU. */
12319 check_producer (struct dwarf2_cu
*cu
)
12324 if (cu
->producer
== NULL
)
12326 /* For unknown compilers expect their behavior is DWARF version
12329 GCC started to support .debug_types sections by -gdwarf-4 since
12330 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12331 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12332 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12333 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12335 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
12337 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
12338 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
12340 else if (startswith (cu
->producer
, "Intel(R) C"))
12341 cu
->producer_is_icc
= 1;
12344 /* For other non-GCC compilers, expect their behavior is DWARF version
12348 cu
->checked_producer
= 1;
12351 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12352 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12353 during 4.6.0 experimental. */
12356 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
12358 if (!cu
->checked_producer
)
12359 check_producer (cu
);
12361 return cu
->producer_is_gxx_lt_4_6
;
12364 /* Return the default accessibility type if it is not overriden by
12365 DW_AT_accessibility. */
12367 static enum dwarf_access_attribute
12368 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
12370 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
12372 /* The default DWARF 2 accessibility for members is public, the default
12373 accessibility for inheritance is private. */
12375 if (die
->tag
!= DW_TAG_inheritance
)
12376 return DW_ACCESS_public
;
12378 return DW_ACCESS_private
;
12382 /* DWARF 3+ defines the default accessibility a different way. The same
12383 rules apply now for DW_TAG_inheritance as for the members and it only
12384 depends on the container kind. */
12386 if (die
->parent
->tag
== DW_TAG_class_type
)
12387 return DW_ACCESS_private
;
12389 return DW_ACCESS_public
;
12393 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12394 offset. If the attribute was not found return 0, otherwise return
12395 1. If it was found but could not properly be handled, set *OFFSET
12399 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
12402 struct attribute
*attr
;
12404 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
12409 /* Note that we do not check for a section offset first here.
12410 This is because DW_AT_data_member_location is new in DWARF 4,
12411 so if we see it, we can assume that a constant form is really
12412 a constant and not a section offset. */
12413 if (attr_form_is_constant (attr
))
12414 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
12415 else if (attr_form_is_section_offset (attr
))
12416 dwarf2_complex_location_expr_complaint ();
12417 else if (attr_form_is_block (attr
))
12418 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12420 dwarf2_complex_location_expr_complaint ();
12428 /* Add an aggregate field to the field list. */
12431 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
12432 struct dwarf2_cu
*cu
)
12434 struct objfile
*objfile
= cu
->objfile
;
12435 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12436 struct nextfield
*new_field
;
12437 struct attribute
*attr
;
12439 const char *fieldname
= "";
12441 /* Allocate a new field list entry and link it in. */
12442 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
12443 make_cleanup (xfree
, new_field
);
12444 memset (new_field
, 0, sizeof (struct nextfield
));
12446 if (die
->tag
== DW_TAG_inheritance
)
12448 new_field
->next
= fip
->baseclasses
;
12449 fip
->baseclasses
= new_field
;
12453 new_field
->next
= fip
->fields
;
12454 fip
->fields
= new_field
;
12458 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12460 new_field
->accessibility
= DW_UNSND (attr
);
12462 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
12463 if (new_field
->accessibility
!= DW_ACCESS_public
)
12464 fip
->non_public_fields
= 1;
12466 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12468 new_field
->virtuality
= DW_UNSND (attr
);
12470 new_field
->virtuality
= DW_VIRTUALITY_none
;
12472 fp
= &new_field
->field
;
12474 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
12478 /* Data member other than a C++ static data member. */
12480 /* Get type of field. */
12481 fp
->type
= die_type (die
, cu
);
12483 SET_FIELD_BITPOS (*fp
, 0);
12485 /* Get bit size of field (zero if none). */
12486 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
12489 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
12493 FIELD_BITSIZE (*fp
) = 0;
12496 /* Get bit offset of field. */
12497 if (handle_data_member_location (die
, cu
, &offset
))
12498 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12499 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
12502 if (gdbarch_bits_big_endian (gdbarch
))
12504 /* For big endian bits, the DW_AT_bit_offset gives the
12505 additional bit offset from the MSB of the containing
12506 anonymous object to the MSB of the field. We don't
12507 have to do anything special since we don't need to
12508 know the size of the anonymous object. */
12509 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
12513 /* For little endian bits, compute the bit offset to the
12514 MSB of the anonymous object, subtract off the number of
12515 bits from the MSB of the field to the MSB of the
12516 object, and then subtract off the number of bits of
12517 the field itself. The result is the bit offset of
12518 the LSB of the field. */
12519 int anonymous_size
;
12520 int bit_offset
= DW_UNSND (attr
);
12522 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12525 /* The size of the anonymous object containing
12526 the bit field is explicit, so use the
12527 indicated size (in bytes). */
12528 anonymous_size
= DW_UNSND (attr
);
12532 /* The size of the anonymous object containing
12533 the bit field must be inferred from the type
12534 attribute of the data member containing the
12536 anonymous_size
= TYPE_LENGTH (fp
->type
);
12538 SET_FIELD_BITPOS (*fp
,
12539 (FIELD_BITPOS (*fp
)
12540 + anonymous_size
* bits_per_byte
12541 - bit_offset
- FIELD_BITSIZE (*fp
)));
12545 /* Get name of field. */
12546 fieldname
= dwarf2_name (die
, cu
);
12547 if (fieldname
== NULL
)
12550 /* The name is already allocated along with this objfile, so we don't
12551 need to duplicate it for the type. */
12552 fp
->name
= fieldname
;
12554 /* Change accessibility for artificial fields (e.g. virtual table
12555 pointer or virtual base class pointer) to private. */
12556 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
12558 FIELD_ARTIFICIAL (*fp
) = 1;
12559 new_field
->accessibility
= DW_ACCESS_private
;
12560 fip
->non_public_fields
= 1;
12563 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
12565 /* C++ static member. */
12567 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12568 is a declaration, but all versions of G++ as of this writing
12569 (so through at least 3.2.1) incorrectly generate
12570 DW_TAG_variable tags. */
12572 const char *physname
;
12574 /* Get name of field. */
12575 fieldname
= dwarf2_name (die
, cu
);
12576 if (fieldname
== NULL
)
12579 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
12581 /* Only create a symbol if this is an external value.
12582 new_symbol checks this and puts the value in the global symbol
12583 table, which we want. If it is not external, new_symbol
12584 will try to put the value in cu->list_in_scope which is wrong. */
12585 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
12587 /* A static const member, not much different than an enum as far as
12588 we're concerned, except that we can support more types. */
12589 new_symbol (die
, NULL
, cu
);
12592 /* Get physical name. */
12593 physname
= dwarf2_physname (fieldname
, die
, cu
);
12595 /* The name is already allocated along with this objfile, so we don't
12596 need to duplicate it for the type. */
12597 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
12598 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12599 FIELD_NAME (*fp
) = fieldname
;
12601 else if (die
->tag
== DW_TAG_inheritance
)
12605 /* C++ base class field. */
12606 if (handle_data_member_location (die
, cu
, &offset
))
12607 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12608 FIELD_BITSIZE (*fp
) = 0;
12609 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12610 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
12611 fip
->nbaseclasses
++;
12615 /* Add a typedef defined in the scope of the FIP's class. */
12618 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
12619 struct dwarf2_cu
*cu
)
12621 struct objfile
*objfile
= cu
->objfile
;
12622 struct typedef_field_list
*new_field
;
12623 struct attribute
*attr
;
12624 struct typedef_field
*fp
;
12625 char *fieldname
= "";
12627 /* Allocate a new field list entry and link it in. */
12628 new_field
= xzalloc (sizeof (*new_field
));
12629 make_cleanup (xfree
, new_field
);
12631 gdb_assert (die
->tag
== DW_TAG_typedef
);
12633 fp
= &new_field
->field
;
12635 /* Get name of field. */
12636 fp
->name
= dwarf2_name (die
, cu
);
12637 if (fp
->name
== NULL
)
12640 fp
->type
= read_type_die (die
, cu
);
12642 new_field
->next
= fip
->typedef_field_list
;
12643 fip
->typedef_field_list
= new_field
;
12644 fip
->typedef_field_list_count
++;
12647 /* Create the vector of fields, and attach it to the type. */
12650 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
12651 struct dwarf2_cu
*cu
)
12653 int nfields
= fip
->nfields
;
12655 /* Record the field count, allocate space for the array of fields,
12656 and create blank accessibility bitfields if necessary. */
12657 TYPE_NFIELDS (type
) = nfields
;
12658 TYPE_FIELDS (type
) = (struct field
*)
12659 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
12660 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
12662 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
12664 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12666 TYPE_FIELD_PRIVATE_BITS (type
) =
12667 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12668 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
12670 TYPE_FIELD_PROTECTED_BITS (type
) =
12671 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12672 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
12674 TYPE_FIELD_IGNORE_BITS (type
) =
12675 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12676 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
12679 /* If the type has baseclasses, allocate and clear a bit vector for
12680 TYPE_FIELD_VIRTUAL_BITS. */
12681 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
12683 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
12684 unsigned char *pointer
;
12686 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12687 pointer
= TYPE_ALLOC (type
, num_bytes
);
12688 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
12689 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
12690 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
12693 /* Copy the saved-up fields into the field vector. Start from the head of
12694 the list, adding to the tail of the field array, so that they end up in
12695 the same order in the array in which they were added to the list. */
12696 while (nfields
-- > 0)
12698 struct nextfield
*fieldp
;
12702 fieldp
= fip
->fields
;
12703 fip
->fields
= fieldp
->next
;
12707 fieldp
= fip
->baseclasses
;
12708 fip
->baseclasses
= fieldp
->next
;
12711 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
12712 switch (fieldp
->accessibility
)
12714 case DW_ACCESS_private
:
12715 if (cu
->language
!= language_ada
)
12716 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
12719 case DW_ACCESS_protected
:
12720 if (cu
->language
!= language_ada
)
12721 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
12724 case DW_ACCESS_public
:
12728 /* Unknown accessibility. Complain and treat it as public. */
12730 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
12731 fieldp
->accessibility
);
12735 if (nfields
< fip
->nbaseclasses
)
12737 switch (fieldp
->virtuality
)
12739 case DW_VIRTUALITY_virtual
:
12740 case DW_VIRTUALITY_pure_virtual
:
12741 if (cu
->language
== language_ada
)
12742 error (_("unexpected virtuality in component of Ada type"));
12743 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
12750 /* Return true if this member function is a constructor, false
12754 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
12756 const char *fieldname
;
12757 const char *type_name
;
12760 if (die
->parent
== NULL
)
12763 if (die
->parent
->tag
!= DW_TAG_structure_type
12764 && die
->parent
->tag
!= DW_TAG_union_type
12765 && die
->parent
->tag
!= DW_TAG_class_type
)
12768 fieldname
= dwarf2_name (die
, cu
);
12769 type_name
= dwarf2_name (die
->parent
, cu
);
12770 if (fieldname
== NULL
|| type_name
== NULL
)
12773 len
= strlen (fieldname
);
12774 return (strncmp (fieldname
, type_name
, len
) == 0
12775 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
12778 /* Add a member function to the proper fieldlist. */
12781 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
12782 struct type
*type
, struct dwarf2_cu
*cu
)
12784 struct objfile
*objfile
= cu
->objfile
;
12785 struct attribute
*attr
;
12786 struct fnfieldlist
*flp
;
12788 struct fn_field
*fnp
;
12789 const char *fieldname
;
12790 struct nextfnfield
*new_fnfield
;
12791 struct type
*this_type
;
12792 enum dwarf_access_attribute accessibility
;
12794 if (cu
->language
== language_ada
)
12795 error (_("unexpected member function in Ada type"));
12797 /* Get name of member function. */
12798 fieldname
= dwarf2_name (die
, cu
);
12799 if (fieldname
== NULL
)
12802 /* Look up member function name in fieldlist. */
12803 for (i
= 0; i
< fip
->nfnfields
; i
++)
12805 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
12809 /* Create new list element if necessary. */
12810 if (i
< fip
->nfnfields
)
12811 flp
= &fip
->fnfieldlists
[i
];
12814 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
12816 fip
->fnfieldlists
= (struct fnfieldlist
*)
12817 xrealloc (fip
->fnfieldlists
,
12818 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
12819 * sizeof (struct fnfieldlist
));
12820 if (fip
->nfnfields
== 0)
12821 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
12823 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
12824 flp
->name
= fieldname
;
12827 i
= fip
->nfnfields
++;
12830 /* Create a new member function field and chain it to the field list
12832 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
12833 make_cleanup (xfree
, new_fnfield
);
12834 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
12835 new_fnfield
->next
= flp
->head
;
12836 flp
->head
= new_fnfield
;
12839 /* Fill in the member function field info. */
12840 fnp
= &new_fnfield
->fnfield
;
12842 /* Delay processing of the physname until later. */
12843 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
12845 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
12850 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
12851 fnp
->physname
= physname
? physname
: "";
12854 fnp
->type
= alloc_type (objfile
);
12855 this_type
= read_type_die (die
, cu
);
12856 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
12858 int nparams
= TYPE_NFIELDS (this_type
);
12860 /* TYPE is the domain of this method, and THIS_TYPE is the type
12861 of the method itself (TYPE_CODE_METHOD). */
12862 smash_to_method_type (fnp
->type
, type
,
12863 TYPE_TARGET_TYPE (this_type
),
12864 TYPE_FIELDS (this_type
),
12865 TYPE_NFIELDS (this_type
),
12866 TYPE_VARARGS (this_type
));
12868 /* Handle static member functions.
12869 Dwarf2 has no clean way to discern C++ static and non-static
12870 member functions. G++ helps GDB by marking the first
12871 parameter for non-static member functions (which is the this
12872 pointer) as artificial. We obtain this information from
12873 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12874 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
12875 fnp
->voffset
= VOFFSET_STATIC
;
12878 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
12879 dwarf2_full_name (fieldname
, die
, cu
));
12881 /* Get fcontext from DW_AT_containing_type if present. */
12882 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
12883 fnp
->fcontext
= die_containing_type (die
, cu
);
12885 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12886 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12888 /* Get accessibility. */
12889 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12891 accessibility
= DW_UNSND (attr
);
12893 accessibility
= dwarf2_default_access_attribute (die
, cu
);
12894 switch (accessibility
)
12896 case DW_ACCESS_private
:
12897 fnp
->is_private
= 1;
12899 case DW_ACCESS_protected
:
12900 fnp
->is_protected
= 1;
12904 /* Check for artificial methods. */
12905 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
12906 if (attr
&& DW_UNSND (attr
) != 0)
12907 fnp
->is_artificial
= 1;
12909 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
12911 /* Get index in virtual function table if it is a virtual member
12912 function. For older versions of GCC, this is an offset in the
12913 appropriate virtual table, as specified by DW_AT_containing_type.
12914 For everyone else, it is an expression to be evaluated relative
12915 to the object address. */
12917 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
12920 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
12922 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
12924 /* Old-style GCC. */
12925 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
12927 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12928 || (DW_BLOCK (attr
)->size
> 1
12929 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
12930 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
12932 struct dwarf_block blk
;
12935 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12937 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
12938 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
12939 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12940 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
12941 dwarf2_complex_location_expr_complaint ();
12943 fnp
->voffset
/= cu
->header
.addr_size
;
12947 dwarf2_complex_location_expr_complaint ();
12949 if (!fnp
->fcontext
)
12951 /* If there is no `this' field and no DW_AT_containing_type,
12952 we cannot actually find a base class context for the
12954 if (TYPE_NFIELDS (this_type
) == 0
12955 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
12957 complaint (&symfile_complaints
,
12958 _("cannot determine context for virtual member "
12959 "function \"%s\" (offset %d)"),
12960 fieldname
, die
->offset
.sect_off
);
12965 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
12969 else if (attr_form_is_section_offset (attr
))
12971 dwarf2_complex_location_expr_complaint ();
12975 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12981 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12982 if (attr
&& DW_UNSND (attr
))
12984 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12985 complaint (&symfile_complaints
,
12986 _("Member function \"%s\" (offset %d) is virtual "
12987 "but the vtable offset is not specified"),
12988 fieldname
, die
->offset
.sect_off
);
12989 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12990 TYPE_CPLUS_DYNAMIC (type
) = 1;
12995 /* Create the vector of member function fields, and attach it to the type. */
12998 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
12999 struct dwarf2_cu
*cu
)
13001 struct fnfieldlist
*flp
;
13004 if (cu
->language
== language_ada
)
13005 error (_("unexpected member functions in Ada type"));
13007 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13008 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
13009 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
13011 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
13013 struct nextfnfield
*nfp
= flp
->head
;
13014 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
13017 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
13018 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
13019 fn_flp
->fn_fields
= (struct fn_field
*)
13020 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
13021 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
13022 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
13025 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
13028 /* Returns non-zero if NAME is the name of a vtable member in CU's
13029 language, zero otherwise. */
13031 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
13033 static const char vptr
[] = "_vptr";
13034 static const char vtable
[] = "vtable";
13036 /* Look for the C++ and Java forms of the vtable. */
13037 if ((cu
->language
== language_java
13038 && startswith (name
, vtable
))
13039 || (startswith (name
, vptr
)
13040 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
13046 /* GCC outputs unnamed structures that are really pointers to member
13047 functions, with the ABI-specified layout. If TYPE describes
13048 such a structure, smash it into a member function type.
13050 GCC shouldn't do this; it should just output pointer to member DIEs.
13051 This is GCC PR debug/28767. */
13054 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
13056 struct type
*pfn_type
, *self_type
, *new_type
;
13058 /* Check for a structure with no name and two children. */
13059 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
13062 /* Check for __pfn and __delta members. */
13063 if (TYPE_FIELD_NAME (type
, 0) == NULL
13064 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
13065 || TYPE_FIELD_NAME (type
, 1) == NULL
13066 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
13069 /* Find the type of the method. */
13070 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
13071 if (pfn_type
== NULL
13072 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
13073 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
13076 /* Look for the "this" argument. */
13077 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
13078 if (TYPE_NFIELDS (pfn_type
) == 0
13079 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
13080 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
13083 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
13084 new_type
= alloc_type (objfile
);
13085 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
13086 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
13087 TYPE_VARARGS (pfn_type
));
13088 smash_to_methodptr_type (type
, new_type
);
13091 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
13095 producer_is_icc (struct dwarf2_cu
*cu
)
13097 if (!cu
->checked_producer
)
13098 check_producer (cu
);
13100 return cu
->producer_is_icc
;
13103 /* Called when we find the DIE that starts a structure or union scope
13104 (definition) to create a type for the structure or union. Fill in
13105 the type's name and general properties; the members will not be
13106 processed until process_structure_scope. A symbol table entry for
13107 the type will also not be done until process_structure_scope (assuming
13108 the type has a name).
13110 NOTE: we need to call these functions regardless of whether or not the
13111 DIE has a DW_AT_name attribute, since it might be an anonymous
13112 structure or union. This gets the type entered into our set of
13113 user defined types. */
13115 static struct type
*
13116 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13118 struct objfile
*objfile
= cu
->objfile
;
13120 struct attribute
*attr
;
13123 /* If the definition of this type lives in .debug_types, read that type.
13124 Don't follow DW_AT_specification though, that will take us back up
13125 the chain and we want to go down. */
13126 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13129 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13131 /* The type's CU may not be the same as CU.
13132 Ensure TYPE is recorded with CU in die_type_hash. */
13133 return set_die_type (die
, type
, cu
);
13136 type
= alloc_type (objfile
);
13137 INIT_CPLUS_SPECIFIC (type
);
13139 name
= dwarf2_name (die
, cu
);
13142 if (cu
->language
== language_cplus
13143 || cu
->language
== language_java
)
13145 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
13147 /* dwarf2_full_name might have already finished building the DIE's
13148 type. If so, there is no need to continue. */
13149 if (get_die_type (die
, cu
) != NULL
)
13150 return get_die_type (die
, cu
);
13152 TYPE_TAG_NAME (type
) = full_name
;
13153 if (die
->tag
== DW_TAG_structure_type
13154 || die
->tag
== DW_TAG_class_type
)
13155 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13159 /* The name is already allocated along with this objfile, so
13160 we don't need to duplicate it for the type. */
13161 TYPE_TAG_NAME (type
) = name
;
13162 if (die
->tag
== DW_TAG_class_type
)
13163 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13167 if (die
->tag
== DW_TAG_structure_type
)
13169 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13171 else if (die
->tag
== DW_TAG_union_type
)
13173 TYPE_CODE (type
) = TYPE_CODE_UNION
;
13177 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13180 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
13181 TYPE_DECLARED_CLASS (type
) = 1;
13183 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13186 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13190 TYPE_LENGTH (type
) = 0;
13193 if (producer_is_icc (cu
) && (TYPE_LENGTH (type
) == 0))
13195 /* ICC does not output the required DW_AT_declaration
13196 on incomplete types, but gives them a size of zero. */
13197 TYPE_STUB (type
) = 1;
13200 TYPE_STUB_SUPPORTED (type
) = 1;
13202 if (die_is_declaration (die
, cu
))
13203 TYPE_STUB (type
) = 1;
13204 else if (attr
== NULL
&& die
->child
== NULL
13205 && producer_is_realview (cu
->producer
))
13206 /* RealView does not output the required DW_AT_declaration
13207 on incomplete types. */
13208 TYPE_STUB (type
) = 1;
13210 /* We need to add the type field to the die immediately so we don't
13211 infinitely recurse when dealing with pointers to the structure
13212 type within the structure itself. */
13213 set_die_type (die
, type
, cu
);
13215 /* set_die_type should be already done. */
13216 set_descriptive_type (type
, die
, cu
);
13221 /* Finish creating a structure or union type, including filling in
13222 its members and creating a symbol for it. */
13225 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13227 struct objfile
*objfile
= cu
->objfile
;
13228 struct die_info
*child_die
;
13231 type
= get_die_type (die
, cu
);
13233 type
= read_structure_type (die
, cu
);
13235 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
13237 struct field_info fi
;
13238 VEC (symbolp
) *template_args
= NULL
;
13239 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
13241 memset (&fi
, 0, sizeof (struct field_info
));
13243 child_die
= die
->child
;
13245 while (child_die
&& child_die
->tag
)
13247 if (child_die
->tag
== DW_TAG_member
13248 || child_die
->tag
== DW_TAG_variable
)
13250 /* NOTE: carlton/2002-11-05: A C++ static data member
13251 should be a DW_TAG_member that is a declaration, but
13252 all versions of G++ as of this writing (so through at
13253 least 3.2.1) incorrectly generate DW_TAG_variable
13254 tags for them instead. */
13255 dwarf2_add_field (&fi
, child_die
, cu
);
13257 else if (child_die
->tag
== DW_TAG_subprogram
)
13259 /* C++ member function. */
13260 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
13262 else if (child_die
->tag
== DW_TAG_inheritance
)
13264 /* C++ base class field. */
13265 dwarf2_add_field (&fi
, child_die
, cu
);
13267 else if (child_die
->tag
== DW_TAG_typedef
)
13268 dwarf2_add_typedef (&fi
, child_die
, cu
);
13269 else if (child_die
->tag
== DW_TAG_template_type_param
13270 || child_die
->tag
== DW_TAG_template_value_param
)
13272 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13275 VEC_safe_push (symbolp
, template_args
, arg
);
13278 child_die
= sibling_die (child_die
);
13281 /* Attach template arguments to type. */
13282 if (! VEC_empty (symbolp
, template_args
))
13284 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13285 TYPE_N_TEMPLATE_ARGUMENTS (type
)
13286 = VEC_length (symbolp
, template_args
);
13287 TYPE_TEMPLATE_ARGUMENTS (type
)
13288 = obstack_alloc (&objfile
->objfile_obstack
,
13289 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
13290 * sizeof (struct symbol
*)));
13291 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
13292 VEC_address (symbolp
, template_args
),
13293 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
13294 * sizeof (struct symbol
*)));
13295 VEC_free (symbolp
, template_args
);
13298 /* Attach fields and member functions to the type. */
13300 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
13303 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
13305 /* Get the type which refers to the base class (possibly this
13306 class itself) which contains the vtable pointer for the current
13307 class from the DW_AT_containing_type attribute. This use of
13308 DW_AT_containing_type is a GNU extension. */
13310 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
13312 struct type
*t
= die_containing_type (die
, cu
);
13314 set_type_vptr_basetype (type
, t
);
13319 /* Our own class provides vtbl ptr. */
13320 for (i
= TYPE_NFIELDS (t
) - 1;
13321 i
>= TYPE_N_BASECLASSES (t
);
13324 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
13326 if (is_vtable_name (fieldname
, cu
))
13328 set_type_vptr_fieldno (type
, i
);
13333 /* Complain if virtual function table field not found. */
13334 if (i
< TYPE_N_BASECLASSES (t
))
13335 complaint (&symfile_complaints
,
13336 _("virtual function table pointer "
13337 "not found when defining class '%s'"),
13338 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
13343 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
13346 else if (cu
->producer
13347 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
13349 /* The IBM XLC compiler does not provide direct indication
13350 of the containing type, but the vtable pointer is
13351 always named __vfp. */
13355 for (i
= TYPE_NFIELDS (type
) - 1;
13356 i
>= TYPE_N_BASECLASSES (type
);
13359 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
13361 set_type_vptr_fieldno (type
, i
);
13362 set_type_vptr_basetype (type
, type
);
13369 /* Copy fi.typedef_field_list linked list elements content into the
13370 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13371 if (fi
.typedef_field_list
)
13373 int i
= fi
.typedef_field_list_count
;
13375 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13376 TYPE_TYPEDEF_FIELD_ARRAY (type
)
13377 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
13378 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
13380 /* Reverse the list order to keep the debug info elements order. */
13383 struct typedef_field
*dest
, *src
;
13385 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
13386 src
= &fi
.typedef_field_list
->field
;
13387 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
13392 do_cleanups (back_to
);
13394 if (HAVE_CPLUS_STRUCT (type
))
13395 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
13398 quirk_gcc_member_function_pointer (type
, objfile
);
13400 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13401 snapshots) has been known to create a die giving a declaration
13402 for a class that has, as a child, a die giving a definition for a
13403 nested class. So we have to process our children even if the
13404 current die is a declaration. Normally, of course, a declaration
13405 won't have any children at all. */
13407 child_die
= die
->child
;
13409 while (child_die
!= NULL
&& child_die
->tag
)
13411 if (child_die
->tag
== DW_TAG_member
13412 || child_die
->tag
== DW_TAG_variable
13413 || child_die
->tag
== DW_TAG_inheritance
13414 || child_die
->tag
== DW_TAG_template_value_param
13415 || child_die
->tag
== DW_TAG_template_type_param
)
13420 process_die (child_die
, cu
);
13422 child_die
= sibling_die (child_die
);
13425 /* Do not consider external references. According to the DWARF standard,
13426 these DIEs are identified by the fact that they have no byte_size
13427 attribute, and a declaration attribute. */
13428 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
13429 || !die_is_declaration (die
, cu
))
13430 new_symbol (die
, type
, cu
);
13433 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13434 update TYPE using some information only available in DIE's children. */
13437 update_enumeration_type_from_children (struct die_info
*die
,
13439 struct dwarf2_cu
*cu
)
13441 struct obstack obstack
;
13442 struct die_info
*child_die
;
13443 int unsigned_enum
= 1;
13446 struct cleanup
*old_chain
;
13448 obstack_init (&obstack
);
13449 old_chain
= make_cleanup_obstack_free (&obstack
);
13451 for (child_die
= die
->child
;
13452 child_die
!= NULL
&& child_die
->tag
;
13453 child_die
= sibling_die (child_die
))
13455 struct attribute
*attr
;
13457 const gdb_byte
*bytes
;
13458 struct dwarf2_locexpr_baton
*baton
;
13461 if (child_die
->tag
!= DW_TAG_enumerator
)
13464 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
13468 name
= dwarf2_name (child_die
, cu
);
13470 name
= "<anonymous enumerator>";
13472 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
13473 &value
, &bytes
, &baton
);
13479 else if ((mask
& value
) != 0)
13484 /* If we already know that the enum type is neither unsigned, nor
13485 a flag type, no need to look at the rest of the enumerates. */
13486 if (!unsigned_enum
&& !flag_enum
)
13491 TYPE_UNSIGNED (type
) = 1;
13493 TYPE_FLAG_ENUM (type
) = 1;
13495 do_cleanups (old_chain
);
13498 /* Given a DW_AT_enumeration_type die, set its type. We do not
13499 complete the type's fields yet, or create any symbols. */
13501 static struct type
*
13502 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13504 struct objfile
*objfile
= cu
->objfile
;
13506 struct attribute
*attr
;
13509 /* If the definition of this type lives in .debug_types, read that type.
13510 Don't follow DW_AT_specification though, that will take us back up
13511 the chain and we want to go down. */
13512 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13515 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13517 /* The type's CU may not be the same as CU.
13518 Ensure TYPE is recorded with CU in die_type_hash. */
13519 return set_die_type (die
, type
, cu
);
13522 type
= alloc_type (objfile
);
13524 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
13525 name
= dwarf2_full_name (NULL
, die
, cu
);
13527 TYPE_TAG_NAME (type
) = name
;
13529 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13532 struct type
*underlying_type
= die_type (die
, cu
);
13534 TYPE_TARGET_TYPE (type
) = underlying_type
;
13537 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13540 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13544 TYPE_LENGTH (type
) = 0;
13547 /* The enumeration DIE can be incomplete. In Ada, any type can be
13548 declared as private in the package spec, and then defined only
13549 inside the package body. Such types are known as Taft Amendment
13550 Types. When another package uses such a type, an incomplete DIE
13551 may be generated by the compiler. */
13552 if (die_is_declaration (die
, cu
))
13553 TYPE_STUB (type
) = 1;
13555 /* Finish the creation of this type by using the enum's children.
13556 We must call this even when the underlying type has been provided
13557 so that we can determine if we're looking at a "flag" enum. */
13558 update_enumeration_type_from_children (die
, type
, cu
);
13560 /* If this type has an underlying type that is not a stub, then we
13561 may use its attributes. We always use the "unsigned" attribute
13562 in this situation, because ordinarily we guess whether the type
13563 is unsigned -- but the guess can be wrong and the underlying type
13564 can tell us the reality. However, we defer to a local size
13565 attribute if one exists, because this lets the compiler override
13566 the underlying type if needed. */
13567 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
13569 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
13570 if (TYPE_LENGTH (type
) == 0)
13571 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
13574 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
13576 return set_die_type (die
, type
, cu
);
13579 /* Given a pointer to a die which begins an enumeration, process all
13580 the dies that define the members of the enumeration, and create the
13581 symbol for the enumeration type.
13583 NOTE: We reverse the order of the element list. */
13586 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13588 struct type
*this_type
;
13590 this_type
= get_die_type (die
, cu
);
13591 if (this_type
== NULL
)
13592 this_type
= read_enumeration_type (die
, cu
);
13594 if (die
->child
!= NULL
)
13596 struct die_info
*child_die
;
13597 struct symbol
*sym
;
13598 struct field
*fields
= NULL
;
13599 int num_fields
= 0;
13602 child_die
= die
->child
;
13603 while (child_die
&& child_die
->tag
)
13605 if (child_die
->tag
!= DW_TAG_enumerator
)
13607 process_die (child_die
, cu
);
13611 name
= dwarf2_name (child_die
, cu
);
13614 sym
= new_symbol (child_die
, this_type
, cu
);
13616 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
13618 fields
= (struct field
*)
13620 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
13621 * sizeof (struct field
));
13624 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
13625 FIELD_TYPE (fields
[num_fields
]) = NULL
;
13626 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
13627 FIELD_BITSIZE (fields
[num_fields
]) = 0;
13633 child_die
= sibling_die (child_die
);
13638 TYPE_NFIELDS (this_type
) = num_fields
;
13639 TYPE_FIELDS (this_type
) = (struct field
*)
13640 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
13641 memcpy (TYPE_FIELDS (this_type
), fields
,
13642 sizeof (struct field
) * num_fields
);
13647 /* If we are reading an enum from a .debug_types unit, and the enum
13648 is a declaration, and the enum is not the signatured type in the
13649 unit, then we do not want to add a symbol for it. Adding a
13650 symbol would in some cases obscure the true definition of the
13651 enum, giving users an incomplete type when the definition is
13652 actually available. Note that we do not want to do this for all
13653 enums which are just declarations, because C++0x allows forward
13654 enum declarations. */
13655 if (cu
->per_cu
->is_debug_types
13656 && die_is_declaration (die
, cu
))
13658 struct signatured_type
*sig_type
;
13660 sig_type
= (struct signatured_type
*) cu
->per_cu
;
13661 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
13662 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
13666 new_symbol (die
, this_type
, cu
);
13669 /* Extract all information from a DW_TAG_array_type DIE and put it in
13670 the DIE's type field. For now, this only handles one dimensional
13673 static struct type
*
13674 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13676 struct objfile
*objfile
= cu
->objfile
;
13677 struct die_info
*child_die
;
13679 struct type
*element_type
, *range_type
, *index_type
;
13680 struct type
**range_types
= NULL
;
13681 struct attribute
*attr
;
13683 struct cleanup
*back_to
;
13685 unsigned int bit_stride
= 0;
13687 element_type
= die_type (die
, cu
);
13689 /* The die_type call above may have already set the type for this DIE. */
13690 type
= get_die_type (die
, cu
);
13694 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
13696 bit_stride
= DW_UNSND (attr
) * 8;
13698 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
13700 bit_stride
= DW_UNSND (attr
);
13702 /* Irix 6.2 native cc creates array types without children for
13703 arrays with unspecified length. */
13704 if (die
->child
== NULL
)
13706 index_type
= objfile_type (objfile
)->builtin_int
;
13707 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
13708 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
13710 return set_die_type (die
, type
, cu
);
13713 back_to
= make_cleanup (null_cleanup
, NULL
);
13714 child_die
= die
->child
;
13715 while (child_die
&& child_die
->tag
)
13717 if (child_die
->tag
== DW_TAG_subrange_type
)
13719 struct type
*child_type
= read_type_die (child_die
, cu
);
13721 if (child_type
!= NULL
)
13723 /* The range type was succesfully read. Save it for the
13724 array type creation. */
13725 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
13727 range_types
= (struct type
**)
13728 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
13729 * sizeof (struct type
*));
13731 make_cleanup (free_current_contents
, &range_types
);
13733 range_types
[ndim
++] = child_type
;
13736 child_die
= sibling_die (child_die
);
13739 /* Dwarf2 dimensions are output from left to right, create the
13740 necessary array types in backwards order. */
13742 type
= element_type
;
13744 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
13749 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
13755 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
13759 /* Understand Dwarf2 support for vector types (like they occur on
13760 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13761 array type. This is not part of the Dwarf2/3 standard yet, but a
13762 custom vendor extension. The main difference between a regular
13763 array and the vector variant is that vectors are passed by value
13765 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
13767 make_vector_type (type
);
13769 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13770 implementation may choose to implement triple vectors using this
13772 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13775 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
13776 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13778 complaint (&symfile_complaints
,
13779 _("DW_AT_byte_size for array type smaller "
13780 "than the total size of elements"));
13783 name
= dwarf2_name (die
, cu
);
13785 TYPE_NAME (type
) = name
;
13787 /* Install the type in the die. */
13788 set_die_type (die
, type
, cu
);
13790 /* set_die_type should be already done. */
13791 set_descriptive_type (type
, die
, cu
);
13793 do_cleanups (back_to
);
13798 static enum dwarf_array_dim_ordering
13799 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
13801 struct attribute
*attr
;
13803 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
13805 if (attr
) return DW_SND (attr
);
13807 /* GNU F77 is a special case, as at 08/2004 array type info is the
13808 opposite order to the dwarf2 specification, but data is still
13809 laid out as per normal fortran.
13811 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13812 version checking. */
13814 if (cu
->language
== language_fortran
13815 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
13817 return DW_ORD_row_major
;
13820 switch (cu
->language_defn
->la_array_ordering
)
13822 case array_column_major
:
13823 return DW_ORD_col_major
;
13824 case array_row_major
:
13826 return DW_ORD_row_major
;
13830 /* Extract all information from a DW_TAG_set_type DIE and put it in
13831 the DIE's type field. */
13833 static struct type
*
13834 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13836 struct type
*domain_type
, *set_type
;
13837 struct attribute
*attr
;
13839 domain_type
= die_type (die
, cu
);
13841 /* The die_type call above may have already set the type for this DIE. */
13842 set_type
= get_die_type (die
, cu
);
13846 set_type
= create_set_type (NULL
, domain_type
);
13848 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13850 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
13852 return set_die_type (die
, set_type
, cu
);
13855 /* A helper for read_common_block that creates a locexpr baton.
13856 SYM is the symbol which we are marking as computed.
13857 COMMON_DIE is the DIE for the common block.
13858 COMMON_LOC is the location expression attribute for the common
13860 MEMBER_LOC is the location expression attribute for the particular
13861 member of the common block that we are processing.
13862 CU is the CU from which the above come. */
13865 mark_common_block_symbol_computed (struct symbol
*sym
,
13866 struct die_info
*common_die
,
13867 struct attribute
*common_loc
,
13868 struct attribute
*member_loc
,
13869 struct dwarf2_cu
*cu
)
13871 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13872 struct dwarf2_locexpr_baton
*baton
;
13874 unsigned int cu_off
;
13875 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
13876 LONGEST offset
= 0;
13878 gdb_assert (common_loc
&& member_loc
);
13879 gdb_assert (attr_form_is_block (common_loc
));
13880 gdb_assert (attr_form_is_block (member_loc
)
13881 || attr_form_is_constant (member_loc
));
13883 baton
= obstack_alloc (&objfile
->objfile_obstack
,
13884 sizeof (struct dwarf2_locexpr_baton
));
13885 baton
->per_cu
= cu
->per_cu
;
13886 gdb_assert (baton
->per_cu
);
13888 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13890 if (attr_form_is_constant (member_loc
))
13892 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
13893 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
13896 baton
->size
+= DW_BLOCK (member_loc
)->size
;
13898 ptr
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
13901 *ptr
++ = DW_OP_call4
;
13902 cu_off
= common_die
->offset
.sect_off
- cu
->per_cu
->offset
.sect_off
;
13903 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
13906 if (attr_form_is_constant (member_loc
))
13908 *ptr
++ = DW_OP_addr
;
13909 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
13910 ptr
+= cu
->header
.addr_size
;
13914 /* We have to copy the data here, because DW_OP_call4 will only
13915 use a DW_AT_location attribute. */
13916 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
13917 ptr
+= DW_BLOCK (member_loc
)->size
;
13920 *ptr
++ = DW_OP_plus
;
13921 gdb_assert (ptr
- baton
->data
== baton
->size
);
13923 SYMBOL_LOCATION_BATON (sym
) = baton
;
13924 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
13927 /* Create appropriate locally-scoped variables for all the
13928 DW_TAG_common_block entries. Also create a struct common_block
13929 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13930 is used to sepate the common blocks name namespace from regular
13934 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
13936 struct attribute
*attr
;
13938 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13941 /* Support the .debug_loc offsets. */
13942 if (attr_form_is_block (attr
))
13946 else if (attr_form_is_section_offset (attr
))
13948 dwarf2_complex_location_expr_complaint ();
13953 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13954 "common block member");
13959 if (die
->child
!= NULL
)
13961 struct objfile
*objfile
= cu
->objfile
;
13962 struct die_info
*child_die
;
13963 size_t n_entries
= 0, size
;
13964 struct common_block
*common_block
;
13965 struct symbol
*sym
;
13967 for (child_die
= die
->child
;
13968 child_die
&& child_die
->tag
;
13969 child_die
= sibling_die (child_die
))
13972 size
= (sizeof (struct common_block
)
13973 + (n_entries
- 1) * sizeof (struct symbol
*));
13974 common_block
= obstack_alloc (&objfile
->objfile_obstack
, size
);
13975 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
13976 common_block
->n_entries
= 0;
13978 for (child_die
= die
->child
;
13979 child_die
&& child_die
->tag
;
13980 child_die
= sibling_die (child_die
))
13982 /* Create the symbol in the DW_TAG_common_block block in the current
13984 sym
= new_symbol (child_die
, NULL
, cu
);
13987 struct attribute
*member_loc
;
13989 common_block
->contents
[common_block
->n_entries
++] = sym
;
13991 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
13995 /* GDB has handled this for a long time, but it is
13996 not specified by DWARF. It seems to have been
13997 emitted by gfortran at least as recently as:
13998 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
13999 complaint (&symfile_complaints
,
14000 _("Variable in common block has "
14001 "DW_AT_data_member_location "
14002 "- DIE at 0x%x [in module %s]"),
14003 child_die
->offset
.sect_off
,
14004 objfile_name (cu
->objfile
));
14006 if (attr_form_is_section_offset (member_loc
))
14007 dwarf2_complex_location_expr_complaint ();
14008 else if (attr_form_is_constant (member_loc
)
14009 || attr_form_is_block (member_loc
))
14012 mark_common_block_symbol_computed (sym
, die
, attr
,
14016 dwarf2_complex_location_expr_complaint ();
14021 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
14022 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
14026 /* Create a type for a C++ namespace. */
14028 static struct type
*
14029 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14031 struct objfile
*objfile
= cu
->objfile
;
14032 const char *previous_prefix
, *name
;
14036 /* For extensions, reuse the type of the original namespace. */
14037 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
14039 struct die_info
*ext_die
;
14040 struct dwarf2_cu
*ext_cu
= cu
;
14042 ext_die
= dwarf2_extension (die
, &ext_cu
);
14043 type
= read_type_die (ext_die
, ext_cu
);
14045 /* EXT_CU may not be the same as CU.
14046 Ensure TYPE is recorded with CU in die_type_hash. */
14047 return set_die_type (die
, type
, cu
);
14050 name
= namespace_name (die
, &is_anonymous
, cu
);
14052 /* Now build the name of the current namespace. */
14054 previous_prefix
= determine_prefix (die
, cu
);
14055 if (previous_prefix
[0] != '\0')
14056 name
= typename_concat (&objfile
->objfile_obstack
,
14057 previous_prefix
, name
, 0, cu
);
14059 /* Create the type. */
14060 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
14062 TYPE_NAME (type
) = name
;
14063 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14065 return set_die_type (die
, type
, cu
);
14068 /* Read a C++ namespace. */
14071 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
14073 struct objfile
*objfile
= cu
->objfile
;
14076 /* Add a symbol associated to this if we haven't seen the namespace
14077 before. Also, add a using directive if it's an anonymous
14080 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
14084 type
= read_type_die (die
, cu
);
14085 new_symbol (die
, type
, cu
);
14087 namespace_name (die
, &is_anonymous
, cu
);
14090 const char *previous_prefix
= determine_prefix (die
, cu
);
14092 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
14093 NULL
, NULL
, 0, &objfile
->objfile_obstack
);
14097 if (die
->child
!= NULL
)
14099 struct die_info
*child_die
= die
->child
;
14101 while (child_die
&& child_die
->tag
)
14103 process_die (child_die
, cu
);
14104 child_die
= sibling_die (child_die
);
14109 /* Read a Fortran module as type. This DIE can be only a declaration used for
14110 imported module. Still we need that type as local Fortran "use ... only"
14111 declaration imports depend on the created type in determine_prefix. */
14113 static struct type
*
14114 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14116 struct objfile
*objfile
= cu
->objfile
;
14117 const char *module_name
;
14120 module_name
= dwarf2_name (die
, cu
);
14122 complaint (&symfile_complaints
,
14123 _("DW_TAG_module has no name, offset 0x%x"),
14124 die
->offset
.sect_off
);
14125 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
14127 /* determine_prefix uses TYPE_TAG_NAME. */
14128 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14130 return set_die_type (die
, type
, cu
);
14133 /* Read a Fortran module. */
14136 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
14138 struct die_info
*child_die
= die
->child
;
14141 type
= read_type_die (die
, cu
);
14142 new_symbol (die
, type
, cu
);
14144 while (child_die
&& child_die
->tag
)
14146 process_die (child_die
, cu
);
14147 child_die
= sibling_die (child_die
);
14151 /* Return the name of the namespace represented by DIE. Set
14152 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
14155 static const char *
14156 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
14158 struct die_info
*current_die
;
14159 const char *name
= NULL
;
14161 /* Loop through the extensions until we find a name. */
14163 for (current_die
= die
;
14164 current_die
!= NULL
;
14165 current_die
= dwarf2_extension (die
, &cu
))
14167 /* We don't use dwarf2_name here so that we can detect the absence
14168 of a name -> anonymous namespace. */
14169 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
14172 name
= DW_STRING (attr
);
14177 /* Is it an anonymous namespace? */
14179 *is_anonymous
= (name
== NULL
);
14181 name
= CP_ANONYMOUS_NAMESPACE_STR
;
14186 /* Extract all information from a DW_TAG_pointer_type DIE and add to
14187 the user defined type vector. */
14189 static struct type
*
14190 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14192 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
14193 struct comp_unit_head
*cu_header
= &cu
->header
;
14195 struct attribute
*attr_byte_size
;
14196 struct attribute
*attr_address_class
;
14197 int byte_size
, addr_class
;
14198 struct type
*target_type
;
14200 target_type
= die_type (die
, cu
);
14202 /* The die_type call above may have already set the type for this DIE. */
14203 type
= get_die_type (die
, cu
);
14207 type
= lookup_pointer_type (target_type
);
14209 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14210 if (attr_byte_size
)
14211 byte_size
= DW_UNSND (attr_byte_size
);
14213 byte_size
= cu_header
->addr_size
;
14215 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
14216 if (attr_address_class
)
14217 addr_class
= DW_UNSND (attr_address_class
);
14219 addr_class
= DW_ADDR_none
;
14221 /* If the pointer size or address class is different than the
14222 default, create a type variant marked as such and set the
14223 length accordingly. */
14224 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
14226 if (gdbarch_address_class_type_flags_p (gdbarch
))
14230 type_flags
= gdbarch_address_class_type_flags
14231 (gdbarch
, byte_size
, addr_class
);
14232 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
14234 type
= make_type_with_address_space (type
, type_flags
);
14236 else if (TYPE_LENGTH (type
) != byte_size
)
14238 complaint (&symfile_complaints
,
14239 _("invalid pointer size %d"), byte_size
);
14243 /* Should we also complain about unhandled address classes? */
14247 TYPE_LENGTH (type
) = byte_size
;
14248 return set_die_type (die
, type
, cu
);
14251 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14252 the user defined type vector. */
14254 static struct type
*
14255 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14258 struct type
*to_type
;
14259 struct type
*domain
;
14261 to_type
= die_type (die
, cu
);
14262 domain
= die_containing_type (die
, cu
);
14264 /* The calls above may have already set the type for this DIE. */
14265 type
= get_die_type (die
, cu
);
14269 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
14270 type
= lookup_methodptr_type (to_type
);
14271 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
14273 struct type
*new_type
= alloc_type (cu
->objfile
);
14275 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
14276 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
14277 TYPE_VARARGS (to_type
));
14278 type
= lookup_methodptr_type (new_type
);
14281 type
= lookup_memberptr_type (to_type
, domain
);
14283 return set_die_type (die
, type
, cu
);
14286 /* Extract all information from a DW_TAG_reference_type DIE and add to
14287 the user defined type vector. */
14289 static struct type
*
14290 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14292 struct comp_unit_head
*cu_header
= &cu
->header
;
14293 struct type
*type
, *target_type
;
14294 struct attribute
*attr
;
14296 target_type
= die_type (die
, cu
);
14298 /* The die_type call above may have already set the type for this DIE. */
14299 type
= get_die_type (die
, cu
);
14303 type
= lookup_reference_type (target_type
);
14304 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14307 TYPE_LENGTH (type
) = DW_UNSND (attr
);
14311 TYPE_LENGTH (type
) = cu_header
->addr_size
;
14313 return set_die_type (die
, type
, cu
);
14316 /* Add the given cv-qualifiers to the element type of the array. GCC
14317 outputs DWARF type qualifiers that apply to an array, not the
14318 element type. But GDB relies on the array element type to carry
14319 the cv-qualifiers. This mimics section 6.7.3 of the C99
14322 static struct type
*
14323 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
14324 struct type
*base_type
, int cnst
, int voltl
)
14326 struct type
*el_type
, *inner_array
;
14328 base_type
= copy_type (base_type
);
14329 inner_array
= base_type
;
14331 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
14333 TYPE_TARGET_TYPE (inner_array
) =
14334 copy_type (TYPE_TARGET_TYPE (inner_array
));
14335 inner_array
= TYPE_TARGET_TYPE (inner_array
);
14338 el_type
= TYPE_TARGET_TYPE (inner_array
);
14339 cnst
|= TYPE_CONST (el_type
);
14340 voltl
|= TYPE_VOLATILE (el_type
);
14341 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
14343 return set_die_type (die
, base_type
, cu
);
14346 static struct type
*
14347 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14349 struct type
*base_type
, *cv_type
;
14351 base_type
= die_type (die
, cu
);
14353 /* The die_type call above may have already set the type for this DIE. */
14354 cv_type
= get_die_type (die
, cu
);
14358 /* In case the const qualifier is applied to an array type, the element type
14359 is so qualified, not the array type (section 6.7.3 of C99). */
14360 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14361 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
14363 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
14364 return set_die_type (die
, cv_type
, cu
);
14367 static struct type
*
14368 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14370 struct type
*base_type
, *cv_type
;
14372 base_type
= die_type (die
, cu
);
14374 /* The die_type call above may have already set the type for this DIE. */
14375 cv_type
= get_die_type (die
, cu
);
14379 /* In case the volatile qualifier is applied to an array type, the
14380 element type is so qualified, not the array type (section 6.7.3
14382 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14383 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
14385 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
14386 return set_die_type (die
, cv_type
, cu
);
14389 /* Handle DW_TAG_restrict_type. */
14391 static struct type
*
14392 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14394 struct type
*base_type
, *cv_type
;
14396 base_type
= die_type (die
, cu
);
14398 /* The die_type call above may have already set the type for this DIE. */
14399 cv_type
= get_die_type (die
, cu
);
14403 cv_type
= make_restrict_type (base_type
);
14404 return set_die_type (die
, cv_type
, cu
);
14407 /* Handle DW_TAG_atomic_type. */
14409 static struct type
*
14410 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14412 struct type
*base_type
, *cv_type
;
14414 base_type
= die_type (die
, cu
);
14416 /* The die_type call above may have already set the type for this DIE. */
14417 cv_type
= get_die_type (die
, cu
);
14421 cv_type
= make_atomic_type (base_type
);
14422 return set_die_type (die
, cv_type
, cu
);
14425 /* Extract all information from a DW_TAG_string_type DIE and add to
14426 the user defined type vector. It isn't really a user defined type,
14427 but it behaves like one, with other DIE's using an AT_user_def_type
14428 attribute to reference it. */
14430 static struct type
*
14431 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14433 struct objfile
*objfile
= cu
->objfile
;
14434 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14435 struct type
*type
, *range_type
, *index_type
, *char_type
;
14436 struct attribute
*attr
;
14437 unsigned int length
;
14439 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
14442 length
= DW_UNSND (attr
);
14446 /* Check for the DW_AT_byte_size attribute. */
14447 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14450 length
= DW_UNSND (attr
);
14458 index_type
= objfile_type (objfile
)->builtin_int
;
14459 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
14460 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
14461 type
= create_string_type (NULL
, char_type
, range_type
);
14463 return set_die_type (die
, type
, cu
);
14466 /* Assuming that DIE corresponds to a function, returns nonzero
14467 if the function is prototyped. */
14470 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
14472 struct attribute
*attr
;
14474 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
14475 if (attr
&& (DW_UNSND (attr
) != 0))
14478 /* The DWARF standard implies that the DW_AT_prototyped attribute
14479 is only meaninful for C, but the concept also extends to other
14480 languages that allow unprototyped functions (Eg: Objective C).
14481 For all other languages, assume that functions are always
14483 if (cu
->language
!= language_c
14484 && cu
->language
!= language_objc
14485 && cu
->language
!= language_opencl
)
14488 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14489 prototyped and unprototyped functions; default to prototyped,
14490 since that is more common in modern code (and RealView warns
14491 about unprototyped functions). */
14492 if (producer_is_realview (cu
->producer
))
14498 /* Handle DIES due to C code like:
14502 int (*funcp)(int a, long l);
14506 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14508 static struct type
*
14509 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14511 struct objfile
*objfile
= cu
->objfile
;
14512 struct type
*type
; /* Type that this function returns. */
14513 struct type
*ftype
; /* Function that returns above type. */
14514 struct attribute
*attr
;
14516 type
= die_type (die
, cu
);
14518 /* The die_type call above may have already set the type for this DIE. */
14519 ftype
= get_die_type (die
, cu
);
14523 ftype
= lookup_function_type (type
);
14525 if (prototyped_function_p (die
, cu
))
14526 TYPE_PROTOTYPED (ftype
) = 1;
14528 /* Store the calling convention in the type if it's available in
14529 the subroutine die. Otherwise set the calling convention to
14530 the default value DW_CC_normal. */
14531 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
14533 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
14534 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
14535 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
14537 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
14539 /* Record whether the function returns normally to its caller or not
14540 if the DWARF producer set that information. */
14541 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
14542 if (attr
&& (DW_UNSND (attr
) != 0))
14543 TYPE_NO_RETURN (ftype
) = 1;
14545 /* We need to add the subroutine type to the die immediately so
14546 we don't infinitely recurse when dealing with parameters
14547 declared as the same subroutine type. */
14548 set_die_type (die
, ftype
, cu
);
14550 if (die
->child
!= NULL
)
14552 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
14553 struct die_info
*child_die
;
14554 int nparams
, iparams
;
14556 /* Count the number of parameters.
14557 FIXME: GDB currently ignores vararg functions, but knows about
14558 vararg member functions. */
14560 child_die
= die
->child
;
14561 while (child_die
&& child_die
->tag
)
14563 if (child_die
->tag
== DW_TAG_formal_parameter
)
14565 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
14566 TYPE_VARARGS (ftype
) = 1;
14567 child_die
= sibling_die (child_die
);
14570 /* Allocate storage for parameters and fill them in. */
14571 TYPE_NFIELDS (ftype
) = nparams
;
14572 TYPE_FIELDS (ftype
) = (struct field
*)
14573 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
14575 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14576 even if we error out during the parameters reading below. */
14577 for (iparams
= 0; iparams
< nparams
; iparams
++)
14578 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
14581 child_die
= die
->child
;
14582 while (child_die
&& child_die
->tag
)
14584 if (child_die
->tag
== DW_TAG_formal_parameter
)
14586 struct type
*arg_type
;
14588 /* DWARF version 2 has no clean way to discern C++
14589 static and non-static member functions. G++ helps
14590 GDB by marking the first parameter for non-static
14591 member functions (which is the this pointer) as
14592 artificial. We pass this information to
14593 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14595 DWARF version 3 added DW_AT_object_pointer, which GCC
14596 4.5 does not yet generate. */
14597 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
14599 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
14602 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
14604 /* GCC/43521: In java, the formal parameter
14605 "this" is sometimes not marked with DW_AT_artificial. */
14606 if (cu
->language
== language_java
)
14608 const char *name
= dwarf2_name (child_die
, cu
);
14610 if (name
&& !strcmp (name
, "this"))
14611 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
14614 arg_type
= die_type (child_die
, cu
);
14616 /* RealView does not mark THIS as const, which the testsuite
14617 expects. GCC marks THIS as const in method definitions,
14618 but not in the class specifications (GCC PR 43053). */
14619 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
14620 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
14623 struct dwarf2_cu
*arg_cu
= cu
;
14624 const char *name
= dwarf2_name (child_die
, cu
);
14626 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
14629 /* If the compiler emits this, use it. */
14630 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
14633 else if (name
&& strcmp (name
, "this") == 0)
14634 /* Function definitions will have the argument names. */
14636 else if (name
== NULL
&& iparams
== 0)
14637 /* Declarations may not have the names, so like
14638 elsewhere in GDB, assume an artificial first
14639 argument is "this". */
14643 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
14647 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
14650 child_die
= sibling_die (child_die
);
14657 static struct type
*
14658 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
14660 struct objfile
*objfile
= cu
->objfile
;
14661 const char *name
= NULL
;
14662 struct type
*this_type
, *target_type
;
14664 name
= dwarf2_full_name (NULL
, die
, cu
);
14665 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
14666 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
14667 TYPE_NAME (this_type
) = name
;
14668 set_die_type (die
, this_type
, cu
);
14669 target_type
= die_type (die
, cu
);
14670 if (target_type
!= this_type
)
14671 TYPE_TARGET_TYPE (this_type
) = target_type
;
14674 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14675 spec and cause infinite loops in GDB. */
14676 complaint (&symfile_complaints
,
14677 _("Self-referential DW_TAG_typedef "
14678 "- DIE at 0x%x [in module %s]"),
14679 die
->offset
.sect_off
, objfile_name (objfile
));
14680 TYPE_TARGET_TYPE (this_type
) = NULL
;
14685 /* Find a representation of a given base type and install
14686 it in the TYPE field of the die. */
14688 static struct type
*
14689 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14691 struct objfile
*objfile
= cu
->objfile
;
14693 struct attribute
*attr
;
14694 int encoding
= 0, size
= 0;
14696 enum type_code code
= TYPE_CODE_INT
;
14697 int type_flags
= 0;
14698 struct type
*target_type
= NULL
;
14700 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
14703 encoding
= DW_UNSND (attr
);
14705 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14708 size
= DW_UNSND (attr
);
14710 name
= dwarf2_name (die
, cu
);
14713 complaint (&symfile_complaints
,
14714 _("DW_AT_name missing from DW_TAG_base_type"));
14719 case DW_ATE_address
:
14720 /* Turn DW_ATE_address into a void * pointer. */
14721 code
= TYPE_CODE_PTR
;
14722 type_flags
|= TYPE_FLAG_UNSIGNED
;
14723 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
14725 case DW_ATE_boolean
:
14726 code
= TYPE_CODE_BOOL
;
14727 type_flags
|= TYPE_FLAG_UNSIGNED
;
14729 case DW_ATE_complex_float
:
14730 code
= TYPE_CODE_COMPLEX
;
14731 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
14733 case DW_ATE_decimal_float
:
14734 code
= TYPE_CODE_DECFLOAT
;
14737 code
= TYPE_CODE_FLT
;
14739 case DW_ATE_signed
:
14741 case DW_ATE_unsigned
:
14742 type_flags
|= TYPE_FLAG_UNSIGNED
;
14743 if (cu
->language
== language_fortran
14745 && startswith (name
, "character("))
14746 code
= TYPE_CODE_CHAR
;
14748 case DW_ATE_signed_char
:
14749 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14750 || cu
->language
== language_pascal
14751 || cu
->language
== language_fortran
)
14752 code
= TYPE_CODE_CHAR
;
14754 case DW_ATE_unsigned_char
:
14755 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14756 || cu
->language
== language_pascal
14757 || cu
->language
== language_fortran
)
14758 code
= TYPE_CODE_CHAR
;
14759 type_flags
|= TYPE_FLAG_UNSIGNED
;
14762 /* We just treat this as an integer and then recognize the
14763 type by name elsewhere. */
14767 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
14768 dwarf_type_encoding_name (encoding
));
14772 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
14773 TYPE_NAME (type
) = name
;
14774 TYPE_TARGET_TYPE (type
) = target_type
;
14776 if (name
&& strcmp (name
, "char") == 0)
14777 TYPE_NOSIGN (type
) = 1;
14779 return set_die_type (die
, type
, cu
);
14782 /* Parse dwarf attribute if it's a block, reference or constant and put the
14783 resulting value of the attribute into struct bound_prop.
14784 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14787 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
14788 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
14790 struct dwarf2_property_baton
*baton
;
14791 struct obstack
*obstack
= &cu
->objfile
->objfile_obstack
;
14793 if (attr
== NULL
|| prop
== NULL
)
14796 if (attr_form_is_block (attr
))
14798 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14799 baton
->referenced_type
= NULL
;
14800 baton
->locexpr
.per_cu
= cu
->per_cu
;
14801 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
14802 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
14803 prop
->data
.baton
= baton
;
14804 prop
->kind
= PROP_LOCEXPR
;
14805 gdb_assert (prop
->data
.baton
!= NULL
);
14807 else if (attr_form_is_ref (attr
))
14809 struct dwarf2_cu
*target_cu
= cu
;
14810 struct die_info
*target_die
;
14811 struct attribute
*target_attr
;
14813 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14814 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
14815 if (target_attr
== NULL
)
14816 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
14818 if (target_attr
== NULL
)
14821 switch (target_attr
->name
)
14823 case DW_AT_location
:
14824 if (attr_form_is_section_offset (target_attr
))
14826 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14827 baton
->referenced_type
= die_type (target_die
, target_cu
);
14828 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
14829 prop
->data
.baton
= baton
;
14830 prop
->kind
= PROP_LOCLIST
;
14831 gdb_assert (prop
->data
.baton
!= NULL
);
14833 else if (attr_form_is_block (target_attr
))
14835 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14836 baton
->referenced_type
= die_type (target_die
, target_cu
);
14837 baton
->locexpr
.per_cu
= cu
->per_cu
;
14838 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
14839 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
14840 prop
->data
.baton
= baton
;
14841 prop
->kind
= PROP_LOCEXPR
;
14842 gdb_assert (prop
->data
.baton
!= NULL
);
14846 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14847 "dynamic property");
14851 case DW_AT_data_member_location
:
14855 if (!handle_data_member_location (target_die
, target_cu
,
14859 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14860 baton
->referenced_type
= read_type_die (target_die
->parent
,
14862 baton
->offset_info
.offset
= offset
;
14863 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
14864 prop
->data
.baton
= baton
;
14865 prop
->kind
= PROP_ADDR_OFFSET
;
14870 else if (attr_form_is_constant (attr
))
14872 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
14873 prop
->kind
= PROP_CONST
;
14877 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
14878 dwarf2_name (die
, cu
));
14885 /* Read the given DW_AT_subrange DIE. */
14887 static struct type
*
14888 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14890 struct type
*base_type
, *orig_base_type
;
14891 struct type
*range_type
;
14892 struct attribute
*attr
;
14893 struct dynamic_prop low
, high
;
14894 int low_default_is_valid
;
14895 int high_bound_is_count
= 0;
14897 LONGEST negative_mask
;
14899 orig_base_type
= die_type (die
, cu
);
14900 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14901 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14902 creating the range type, but we use the result of check_typedef
14903 when examining properties of the type. */
14904 base_type
= check_typedef (orig_base_type
);
14906 /* The die_type call above may have already set the type for this DIE. */
14907 range_type
= get_die_type (die
, cu
);
14911 low
.kind
= PROP_CONST
;
14912 high
.kind
= PROP_CONST
;
14913 high
.data
.const_val
= 0;
14915 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14916 omitting DW_AT_lower_bound. */
14917 switch (cu
->language
)
14920 case language_cplus
:
14921 low
.data
.const_val
= 0;
14922 low_default_is_valid
= 1;
14924 case language_fortran
:
14925 low
.data
.const_val
= 1;
14926 low_default_is_valid
= 1;
14929 case language_java
:
14930 case language_objc
:
14931 low
.data
.const_val
= 0;
14932 low_default_is_valid
= (cu
->header
.version
>= 4);
14936 case language_pascal
:
14937 low
.data
.const_val
= 1;
14938 low_default_is_valid
= (cu
->header
.version
>= 4);
14941 low
.data
.const_val
= 0;
14942 low_default_is_valid
= 0;
14946 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
14948 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
14949 else if (!low_default_is_valid
)
14950 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
14951 "- DIE at 0x%x [in module %s]"),
14952 die
->offset
.sect_off
, objfile_name (cu
->objfile
));
14954 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
14955 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14957 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
14958 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14960 /* If bounds are constant do the final calculation here. */
14961 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
14962 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
14964 high_bound_is_count
= 1;
14968 /* Dwarf-2 specifications explicitly allows to create subrange types
14969 without specifying a base type.
14970 In that case, the base type must be set to the type of
14971 the lower bound, upper bound or count, in that order, if any of these
14972 three attributes references an object that has a type.
14973 If no base type is found, the Dwarf-2 specifications say that
14974 a signed integer type of size equal to the size of an address should
14976 For the following C code: `extern char gdb_int [];'
14977 GCC produces an empty range DIE.
14978 FIXME: muller/2010-05-28: Possible references to object for low bound,
14979 high bound or count are not yet handled by this code. */
14980 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
14982 struct objfile
*objfile
= cu
->objfile
;
14983 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14984 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
14985 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
14987 /* Test "int", "long int", and "long long int" objfile types,
14988 and select the first one having a size above or equal to the
14989 architecture address size. */
14990 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14991 base_type
= int_type
;
14994 int_type
= objfile_type (objfile
)->builtin_long
;
14995 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
14996 base_type
= int_type
;
14999 int_type
= objfile_type (objfile
)->builtin_long_long
;
15000 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15001 base_type
= int_type
;
15006 /* Normally, the DWARF producers are expected to use a signed
15007 constant form (Eg. DW_FORM_sdata) to express negative bounds.
15008 But this is unfortunately not always the case, as witnessed
15009 with GCC, for instance, where the ambiguous DW_FORM_dataN form
15010 is used instead. To work around that ambiguity, we treat
15011 the bounds as signed, and thus sign-extend their values, when
15012 the base type is signed. */
15014 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
15015 if (low
.kind
== PROP_CONST
15016 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
15017 low
.data
.const_val
|= negative_mask
;
15018 if (high
.kind
== PROP_CONST
15019 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
15020 high
.data
.const_val
|= negative_mask
;
15022 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
15024 if (high_bound_is_count
)
15025 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
15027 /* Ada expects an empty array on no boundary attributes. */
15028 if (attr
== NULL
&& cu
->language
!= language_ada
)
15029 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
15031 name
= dwarf2_name (die
, cu
);
15033 TYPE_NAME (range_type
) = name
;
15035 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15037 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
15039 set_die_type (die
, range_type
, cu
);
15041 /* set_die_type should be already done. */
15042 set_descriptive_type (range_type
, die
, cu
);
15047 static struct type
*
15048 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15052 /* For now, we only support the C meaning of an unspecified type: void. */
15054 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
15055 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
15057 return set_die_type (die
, type
, cu
);
15060 /* Read a single die and all its descendents. Set the die's sibling
15061 field to NULL; set other fields in the die correctly, and set all
15062 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
15063 location of the info_ptr after reading all of those dies. PARENT
15064 is the parent of the die in question. */
15066 static struct die_info
*
15067 read_die_and_children (const struct die_reader_specs
*reader
,
15068 const gdb_byte
*info_ptr
,
15069 const gdb_byte
**new_info_ptr
,
15070 struct die_info
*parent
)
15072 struct die_info
*die
;
15073 const gdb_byte
*cur_ptr
;
15076 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
15079 *new_info_ptr
= cur_ptr
;
15082 store_in_ref_table (die
, reader
->cu
);
15085 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
15089 *new_info_ptr
= cur_ptr
;
15092 die
->sibling
= NULL
;
15093 die
->parent
= parent
;
15097 /* Read a die, all of its descendents, and all of its siblings; set
15098 all of the fields of all of the dies correctly. Arguments are as
15099 in read_die_and_children. */
15101 static struct die_info
*
15102 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
15103 const gdb_byte
*info_ptr
,
15104 const gdb_byte
**new_info_ptr
,
15105 struct die_info
*parent
)
15107 struct die_info
*first_die
, *last_sibling
;
15108 const gdb_byte
*cur_ptr
;
15110 cur_ptr
= info_ptr
;
15111 first_die
= last_sibling
= NULL
;
15115 struct die_info
*die
15116 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
15120 *new_info_ptr
= cur_ptr
;
15127 last_sibling
->sibling
= die
;
15129 last_sibling
= die
;
15133 /* Read a die, all of its descendents, and all of its siblings; set
15134 all of the fields of all of the dies correctly. Arguments are as
15135 in read_die_and_children.
15136 This the main entry point for reading a DIE and all its children. */
15138 static struct die_info
*
15139 read_die_and_siblings (const struct die_reader_specs
*reader
,
15140 const gdb_byte
*info_ptr
,
15141 const gdb_byte
**new_info_ptr
,
15142 struct die_info
*parent
)
15144 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
15145 new_info_ptr
, parent
);
15147 if (dwarf_die_debug
)
15149 fprintf_unfiltered (gdb_stdlog
,
15150 "Read die from %s@0x%x of %s:\n",
15151 get_section_name (reader
->die_section
),
15152 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15153 bfd_get_filename (reader
->abfd
));
15154 dump_die (die
, dwarf_die_debug
);
15160 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
15162 The caller is responsible for filling in the extra attributes
15163 and updating (*DIEP)->num_attrs.
15164 Set DIEP to point to a newly allocated die with its information,
15165 except for its child, sibling, and parent fields.
15166 Set HAS_CHILDREN to tell whether the die has children or not. */
15168 static const gdb_byte
*
15169 read_full_die_1 (const struct die_reader_specs
*reader
,
15170 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15171 int *has_children
, int num_extra_attrs
)
15173 unsigned int abbrev_number
, bytes_read
, i
;
15174 sect_offset offset
;
15175 struct abbrev_info
*abbrev
;
15176 struct die_info
*die
;
15177 struct dwarf2_cu
*cu
= reader
->cu
;
15178 bfd
*abfd
= reader
->abfd
;
15180 offset
.sect_off
= info_ptr
- reader
->buffer
;
15181 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15182 info_ptr
+= bytes_read
;
15183 if (!abbrev_number
)
15190 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
15192 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
15194 bfd_get_filename (abfd
));
15196 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
15197 die
->offset
= offset
;
15198 die
->tag
= abbrev
->tag
;
15199 die
->abbrev
= abbrev_number
;
15201 /* Make the result usable.
15202 The caller needs to update num_attrs after adding the extra
15204 die
->num_attrs
= abbrev
->num_attrs
;
15206 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15207 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
15211 *has_children
= abbrev
->has_children
;
15215 /* Read a die and all its attributes.
15216 Set DIEP to point to a newly allocated die with its information,
15217 except for its child, sibling, and parent fields.
15218 Set HAS_CHILDREN to tell whether the die has children or not. */
15220 static const gdb_byte
*
15221 read_full_die (const struct die_reader_specs
*reader
,
15222 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15225 const gdb_byte
*result
;
15227 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
15229 if (dwarf_die_debug
)
15231 fprintf_unfiltered (gdb_stdlog
,
15232 "Read die from %s@0x%x of %s:\n",
15233 get_section_name (reader
->die_section
),
15234 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15235 bfd_get_filename (reader
->abfd
));
15236 dump_die (*diep
, dwarf_die_debug
);
15242 /* Abbreviation tables.
15244 In DWARF version 2, the description of the debugging information is
15245 stored in a separate .debug_abbrev section. Before we read any
15246 dies from a section we read in all abbreviations and install them
15247 in a hash table. */
15249 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
15251 static struct abbrev_info
*
15252 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
15254 struct abbrev_info
*abbrev
;
15256 abbrev
= (struct abbrev_info
*)
15257 obstack_alloc (&abbrev_table
->abbrev_obstack
, sizeof (struct abbrev_info
));
15258 memset (abbrev
, 0, sizeof (struct abbrev_info
));
15262 /* Add an abbreviation to the table. */
15265 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
15266 unsigned int abbrev_number
,
15267 struct abbrev_info
*abbrev
)
15269 unsigned int hash_number
;
15271 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15272 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
15273 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
15276 /* Look up an abbrev in the table.
15277 Returns NULL if the abbrev is not found. */
15279 static struct abbrev_info
*
15280 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
15281 unsigned int abbrev_number
)
15283 unsigned int hash_number
;
15284 struct abbrev_info
*abbrev
;
15286 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15287 abbrev
= abbrev_table
->abbrevs
[hash_number
];
15291 if (abbrev
->number
== abbrev_number
)
15293 abbrev
= abbrev
->next
;
15298 /* Read in an abbrev table. */
15300 static struct abbrev_table
*
15301 abbrev_table_read_table (struct dwarf2_section_info
*section
,
15302 sect_offset offset
)
15304 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15305 bfd
*abfd
= get_section_bfd_owner (section
);
15306 struct abbrev_table
*abbrev_table
;
15307 const gdb_byte
*abbrev_ptr
;
15308 struct abbrev_info
*cur_abbrev
;
15309 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
15310 unsigned int abbrev_form
;
15311 struct attr_abbrev
*cur_attrs
;
15312 unsigned int allocated_attrs
;
15314 abbrev_table
= XNEW (struct abbrev_table
);
15315 abbrev_table
->offset
= offset
;
15316 obstack_init (&abbrev_table
->abbrev_obstack
);
15317 abbrev_table
->abbrevs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15319 * sizeof (struct abbrev_info
*)));
15320 memset (abbrev_table
->abbrevs
, 0,
15321 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
15323 dwarf2_read_section (objfile
, section
);
15324 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
15325 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15326 abbrev_ptr
+= bytes_read
;
15328 allocated_attrs
= ATTR_ALLOC_CHUNK
;
15329 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
15331 /* Loop until we reach an abbrev number of 0. */
15332 while (abbrev_number
)
15334 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
15336 /* read in abbrev header */
15337 cur_abbrev
->number
= abbrev_number
;
15338 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15339 abbrev_ptr
+= bytes_read
;
15340 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
15343 /* now read in declarations */
15344 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15345 abbrev_ptr
+= bytes_read
;
15346 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15347 abbrev_ptr
+= bytes_read
;
15348 while (abbrev_name
)
15350 if (cur_abbrev
->num_attrs
== allocated_attrs
)
15352 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
15354 = xrealloc (cur_attrs
, (allocated_attrs
15355 * sizeof (struct attr_abbrev
)));
15358 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
15359 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
15360 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15361 abbrev_ptr
+= bytes_read
;
15362 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15363 abbrev_ptr
+= bytes_read
;
15366 cur_abbrev
->attrs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15367 (cur_abbrev
->num_attrs
15368 * sizeof (struct attr_abbrev
)));
15369 memcpy (cur_abbrev
->attrs
, cur_attrs
,
15370 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
15372 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
15374 /* Get next abbreviation.
15375 Under Irix6 the abbreviations for a compilation unit are not
15376 always properly terminated with an abbrev number of 0.
15377 Exit loop if we encounter an abbreviation which we have
15378 already read (which means we are about to read the abbreviations
15379 for the next compile unit) or if the end of the abbreviation
15380 table is reached. */
15381 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
15383 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15384 abbrev_ptr
+= bytes_read
;
15385 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
15390 return abbrev_table
;
15393 /* Free the resources held by ABBREV_TABLE. */
15396 abbrev_table_free (struct abbrev_table
*abbrev_table
)
15398 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
15399 xfree (abbrev_table
);
15402 /* Same as abbrev_table_free but as a cleanup.
15403 We pass in a pointer to the pointer to the table so that we can
15404 set the pointer to NULL when we're done. It also simplifies
15405 build_type_psymtabs_1. */
15408 abbrev_table_free_cleanup (void *table_ptr
)
15410 struct abbrev_table
**abbrev_table_ptr
= table_ptr
;
15412 if (*abbrev_table_ptr
!= NULL
)
15413 abbrev_table_free (*abbrev_table_ptr
);
15414 *abbrev_table_ptr
= NULL
;
15417 /* Read the abbrev table for CU from ABBREV_SECTION. */
15420 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
15421 struct dwarf2_section_info
*abbrev_section
)
15424 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
15427 /* Release the memory used by the abbrev table for a compilation unit. */
15430 dwarf2_free_abbrev_table (void *ptr_to_cu
)
15432 struct dwarf2_cu
*cu
= ptr_to_cu
;
15434 if (cu
->abbrev_table
!= NULL
)
15435 abbrev_table_free (cu
->abbrev_table
);
15436 /* Set this to NULL so that we SEGV if we try to read it later,
15437 and also because free_comp_unit verifies this is NULL. */
15438 cu
->abbrev_table
= NULL
;
15441 /* Returns nonzero if TAG represents a type that we might generate a partial
15445 is_type_tag_for_partial (int tag
)
15450 /* Some types that would be reasonable to generate partial symbols for,
15451 that we don't at present. */
15452 case DW_TAG_array_type
:
15453 case DW_TAG_file_type
:
15454 case DW_TAG_ptr_to_member_type
:
15455 case DW_TAG_set_type
:
15456 case DW_TAG_string_type
:
15457 case DW_TAG_subroutine_type
:
15459 case DW_TAG_base_type
:
15460 case DW_TAG_class_type
:
15461 case DW_TAG_interface_type
:
15462 case DW_TAG_enumeration_type
:
15463 case DW_TAG_structure_type
:
15464 case DW_TAG_subrange_type
:
15465 case DW_TAG_typedef
:
15466 case DW_TAG_union_type
:
15473 /* Load all DIEs that are interesting for partial symbols into memory. */
15475 static struct partial_die_info
*
15476 load_partial_dies (const struct die_reader_specs
*reader
,
15477 const gdb_byte
*info_ptr
, int building_psymtab
)
15479 struct dwarf2_cu
*cu
= reader
->cu
;
15480 struct objfile
*objfile
= cu
->objfile
;
15481 struct partial_die_info
*part_die
;
15482 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
15483 struct abbrev_info
*abbrev
;
15484 unsigned int bytes_read
;
15485 unsigned int load_all
= 0;
15486 int nesting_level
= 1;
15491 gdb_assert (cu
->per_cu
!= NULL
);
15492 if (cu
->per_cu
->load_all_dies
)
15496 = htab_create_alloc_ex (cu
->header
.length
/ 12,
15500 &cu
->comp_unit_obstack
,
15501 hashtab_obstack_allocate
,
15502 dummy_obstack_deallocate
);
15504 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15505 sizeof (struct partial_die_info
));
15509 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
15511 /* A NULL abbrev means the end of a series of children. */
15512 if (abbrev
== NULL
)
15514 if (--nesting_level
== 0)
15516 /* PART_DIE was probably the last thing allocated on the
15517 comp_unit_obstack, so we could call obstack_free
15518 here. We don't do that because the waste is small,
15519 and will be cleaned up when we're done with this
15520 compilation unit. This way, we're also more robust
15521 against other users of the comp_unit_obstack. */
15524 info_ptr
+= bytes_read
;
15525 last_die
= parent_die
;
15526 parent_die
= parent_die
->die_parent
;
15530 /* Check for template arguments. We never save these; if
15531 they're seen, we just mark the parent, and go on our way. */
15532 if (parent_die
!= NULL
15533 && cu
->language
== language_cplus
15534 && (abbrev
->tag
== DW_TAG_template_type_param
15535 || abbrev
->tag
== DW_TAG_template_value_param
))
15537 parent_die
->has_template_arguments
= 1;
15541 /* We don't need a partial DIE for the template argument. */
15542 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15547 /* We only recurse into c++ subprograms looking for template arguments.
15548 Skip their other children. */
15550 && cu
->language
== language_cplus
15551 && parent_die
!= NULL
15552 && parent_die
->tag
== DW_TAG_subprogram
)
15554 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15558 /* Check whether this DIE is interesting enough to save. Normally
15559 we would not be interested in members here, but there may be
15560 later variables referencing them via DW_AT_specification (for
15561 static members). */
15563 && !is_type_tag_for_partial (abbrev
->tag
)
15564 && abbrev
->tag
!= DW_TAG_constant
15565 && abbrev
->tag
!= DW_TAG_enumerator
15566 && abbrev
->tag
!= DW_TAG_subprogram
15567 && abbrev
->tag
!= DW_TAG_lexical_block
15568 && abbrev
->tag
!= DW_TAG_variable
15569 && abbrev
->tag
!= DW_TAG_namespace
15570 && abbrev
->tag
!= DW_TAG_module
15571 && abbrev
->tag
!= DW_TAG_member
15572 && abbrev
->tag
!= DW_TAG_imported_unit
15573 && abbrev
->tag
!= DW_TAG_imported_declaration
)
15575 /* Otherwise we skip to the next sibling, if any. */
15576 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15580 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
15583 /* This two-pass algorithm for processing partial symbols has a
15584 high cost in cache pressure. Thus, handle some simple cases
15585 here which cover the majority of C partial symbols. DIEs
15586 which neither have specification tags in them, nor could have
15587 specification tags elsewhere pointing at them, can simply be
15588 processed and discarded.
15590 This segment is also optional; scan_partial_symbols and
15591 add_partial_symbol will handle these DIEs if we chain
15592 them in normally. When compilers which do not emit large
15593 quantities of duplicate debug information are more common,
15594 this code can probably be removed. */
15596 /* Any complete simple types at the top level (pretty much all
15597 of them, for a language without namespaces), can be processed
15599 if (parent_die
== NULL
15600 && part_die
->has_specification
== 0
15601 && part_die
->is_declaration
== 0
15602 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
15603 || part_die
->tag
== DW_TAG_base_type
15604 || part_die
->tag
== DW_TAG_subrange_type
))
15606 if (building_psymtab
&& part_die
->name
!= NULL
)
15607 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15608 VAR_DOMAIN
, LOC_TYPEDEF
,
15609 &objfile
->static_psymbols
,
15610 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15611 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15615 /* The exception for DW_TAG_typedef with has_children above is
15616 a workaround of GCC PR debug/47510. In the case of this complaint
15617 type_name_no_tag_or_error will error on such types later.
15619 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15620 it could not find the child DIEs referenced later, this is checked
15621 above. In correct DWARF DW_TAG_typedef should have no children. */
15623 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
15624 complaint (&symfile_complaints
,
15625 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15626 "- DIE at 0x%x [in module %s]"),
15627 part_die
->offset
.sect_off
, objfile_name (objfile
));
15629 /* If we're at the second level, and we're an enumerator, and
15630 our parent has no specification (meaning possibly lives in a
15631 namespace elsewhere), then we can add the partial symbol now
15632 instead of queueing it. */
15633 if (part_die
->tag
== DW_TAG_enumerator
15634 && parent_die
!= NULL
15635 && parent_die
->die_parent
== NULL
15636 && parent_die
->tag
== DW_TAG_enumeration_type
15637 && parent_die
->has_specification
== 0)
15639 if (part_die
->name
== NULL
)
15640 complaint (&symfile_complaints
,
15641 _("malformed enumerator DIE ignored"));
15642 else if (building_psymtab
)
15643 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15644 VAR_DOMAIN
, LOC_CONST
,
15645 (cu
->language
== language_cplus
15646 || cu
->language
== language_java
)
15647 ? &objfile
->global_psymbols
15648 : &objfile
->static_psymbols
,
15649 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15651 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15655 /* We'll save this DIE so link it in. */
15656 part_die
->die_parent
= parent_die
;
15657 part_die
->die_sibling
= NULL
;
15658 part_die
->die_child
= NULL
;
15660 if (last_die
&& last_die
== parent_die
)
15661 last_die
->die_child
= part_die
;
15663 last_die
->die_sibling
= part_die
;
15665 last_die
= part_die
;
15667 if (first_die
== NULL
)
15668 first_die
= part_die
;
15670 /* Maybe add the DIE to the hash table. Not all DIEs that we
15671 find interesting need to be in the hash table, because we
15672 also have the parent/sibling/child chains; only those that we
15673 might refer to by offset later during partial symbol reading.
15675 For now this means things that might have be the target of a
15676 DW_AT_specification, DW_AT_abstract_origin, or
15677 DW_AT_extension. DW_AT_extension will refer only to
15678 namespaces; DW_AT_abstract_origin refers to functions (and
15679 many things under the function DIE, but we do not recurse
15680 into function DIEs during partial symbol reading) and
15681 possibly variables as well; DW_AT_specification refers to
15682 declarations. Declarations ought to have the DW_AT_declaration
15683 flag. It happens that GCC forgets to put it in sometimes, but
15684 only for functions, not for types.
15686 Adding more things than necessary to the hash table is harmless
15687 except for the performance cost. Adding too few will result in
15688 wasted time in find_partial_die, when we reread the compilation
15689 unit with load_all_dies set. */
15692 || abbrev
->tag
== DW_TAG_constant
15693 || abbrev
->tag
== DW_TAG_subprogram
15694 || abbrev
->tag
== DW_TAG_variable
15695 || abbrev
->tag
== DW_TAG_namespace
15696 || part_die
->is_declaration
)
15700 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
15701 part_die
->offset
.sect_off
, INSERT
);
15705 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15706 sizeof (struct partial_die_info
));
15708 /* For some DIEs we want to follow their children (if any). For C
15709 we have no reason to follow the children of structures; for other
15710 languages we have to, so that we can get at method physnames
15711 to infer fully qualified class names, for DW_AT_specification,
15712 and for C++ template arguments. For C++, we also look one level
15713 inside functions to find template arguments (if the name of the
15714 function does not already contain the template arguments).
15716 For Ada, we need to scan the children of subprograms and lexical
15717 blocks as well because Ada allows the definition of nested
15718 entities that could be interesting for the debugger, such as
15719 nested subprograms for instance. */
15720 if (last_die
->has_children
15722 || last_die
->tag
== DW_TAG_namespace
15723 || last_die
->tag
== DW_TAG_module
15724 || last_die
->tag
== DW_TAG_enumeration_type
15725 || (cu
->language
== language_cplus
15726 && last_die
->tag
== DW_TAG_subprogram
15727 && (last_die
->name
== NULL
15728 || strchr (last_die
->name
, '<') == NULL
))
15729 || (cu
->language
!= language_c
15730 && (last_die
->tag
== DW_TAG_class_type
15731 || last_die
->tag
== DW_TAG_interface_type
15732 || last_die
->tag
== DW_TAG_structure_type
15733 || last_die
->tag
== DW_TAG_union_type
))
15734 || (cu
->language
== language_ada
15735 && (last_die
->tag
== DW_TAG_subprogram
15736 || last_die
->tag
== DW_TAG_lexical_block
))))
15739 parent_die
= last_die
;
15743 /* Otherwise we skip to the next sibling, if any. */
15744 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
15746 /* Back to the top, do it again. */
15750 /* Read a minimal amount of information into the minimal die structure. */
15752 static const gdb_byte
*
15753 read_partial_die (const struct die_reader_specs
*reader
,
15754 struct partial_die_info
*part_die
,
15755 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
15756 const gdb_byte
*info_ptr
)
15758 struct dwarf2_cu
*cu
= reader
->cu
;
15759 struct objfile
*objfile
= cu
->objfile
;
15760 const gdb_byte
*buffer
= reader
->buffer
;
15762 struct attribute attr
;
15763 int has_low_pc_attr
= 0;
15764 int has_high_pc_attr
= 0;
15765 int high_pc_relative
= 0;
15767 memset (part_die
, 0, sizeof (struct partial_die_info
));
15769 part_die
->offset
.sect_off
= info_ptr
- buffer
;
15771 info_ptr
+= abbrev_len
;
15773 if (abbrev
== NULL
)
15776 part_die
->tag
= abbrev
->tag
;
15777 part_die
->has_children
= abbrev
->has_children
;
15779 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15781 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
15783 /* Store the data if it is of an attribute we want to keep in a
15784 partial symbol table. */
15788 switch (part_die
->tag
)
15790 case DW_TAG_compile_unit
:
15791 case DW_TAG_partial_unit
:
15792 case DW_TAG_type_unit
:
15793 /* Compilation units have a DW_AT_name that is a filename, not
15794 a source language identifier. */
15795 case DW_TAG_enumeration_type
:
15796 case DW_TAG_enumerator
:
15797 /* These tags always have simple identifiers already; no need
15798 to canonicalize them. */
15799 part_die
->name
= DW_STRING (&attr
);
15803 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
15804 &objfile
->per_bfd
->storage_obstack
);
15808 case DW_AT_linkage_name
:
15809 case DW_AT_MIPS_linkage_name
:
15810 /* Note that both forms of linkage name might appear. We
15811 assume they will be the same, and we only store the last
15813 if (cu
->language
== language_ada
)
15814 part_die
->name
= DW_STRING (&attr
);
15815 part_die
->linkage_name
= DW_STRING (&attr
);
15818 has_low_pc_attr
= 1;
15819 part_die
->lowpc
= attr_value_as_address (&attr
);
15821 case DW_AT_high_pc
:
15822 has_high_pc_attr
= 1;
15823 part_die
->highpc
= attr_value_as_address (&attr
);
15824 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
15825 high_pc_relative
= 1;
15827 case DW_AT_location
:
15828 /* Support the .debug_loc offsets. */
15829 if (attr_form_is_block (&attr
))
15831 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
15833 else if (attr_form_is_section_offset (&attr
))
15835 dwarf2_complex_location_expr_complaint ();
15839 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15840 "partial symbol information");
15843 case DW_AT_external
:
15844 part_die
->is_external
= DW_UNSND (&attr
);
15846 case DW_AT_declaration
:
15847 part_die
->is_declaration
= DW_UNSND (&attr
);
15850 part_die
->has_type
= 1;
15852 case DW_AT_abstract_origin
:
15853 case DW_AT_specification
:
15854 case DW_AT_extension
:
15855 part_die
->has_specification
= 1;
15856 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
15857 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15858 || cu
->per_cu
->is_dwz
);
15860 case DW_AT_sibling
:
15861 /* Ignore absolute siblings, they might point outside of
15862 the current compile unit. */
15863 if (attr
.form
== DW_FORM_ref_addr
)
15864 complaint (&symfile_complaints
,
15865 _("ignoring absolute DW_AT_sibling"));
15868 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
15869 const gdb_byte
*sibling_ptr
= buffer
+ off
;
15871 if (sibling_ptr
< info_ptr
)
15872 complaint (&symfile_complaints
,
15873 _("DW_AT_sibling points backwards"));
15874 else if (sibling_ptr
> reader
->buffer_end
)
15875 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
15877 part_die
->sibling
= sibling_ptr
;
15880 case DW_AT_byte_size
:
15881 part_die
->has_byte_size
= 1;
15883 case DW_AT_const_value
:
15884 part_die
->has_const_value
= 1;
15886 case DW_AT_calling_convention
:
15887 /* DWARF doesn't provide a way to identify a program's source-level
15888 entry point. DW_AT_calling_convention attributes are only meant
15889 to describe functions' calling conventions.
15891 However, because it's a necessary piece of information in
15892 Fortran, and because DW_CC_program is the only piece of debugging
15893 information whose definition refers to a 'main program' at all,
15894 several compilers have begun marking Fortran main programs with
15895 DW_CC_program --- even when those functions use the standard
15896 calling conventions.
15898 So until DWARF specifies a way to provide this information and
15899 compilers pick up the new representation, we'll support this
15901 if (DW_UNSND (&attr
) == DW_CC_program
15902 && cu
->language
== language_fortran
)
15903 set_objfile_main_name (objfile
, part_die
->name
, language_fortran
);
15906 if (DW_UNSND (&attr
) == DW_INL_inlined
15907 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
15908 part_die
->may_be_inlined
= 1;
15912 if (part_die
->tag
== DW_TAG_imported_unit
)
15914 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
15915 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15916 || cu
->per_cu
->is_dwz
);
15925 if (high_pc_relative
)
15926 part_die
->highpc
+= part_die
->lowpc
;
15928 if (has_low_pc_attr
&& has_high_pc_attr
)
15930 /* When using the GNU linker, .gnu.linkonce. sections are used to
15931 eliminate duplicate copies of functions and vtables and such.
15932 The linker will arbitrarily choose one and discard the others.
15933 The AT_*_pc values for such functions refer to local labels in
15934 these sections. If the section from that file was discarded, the
15935 labels are not in the output, so the relocs get a value of 0.
15936 If this is a discarded function, mark the pc bounds as invalid,
15937 so that GDB will ignore it. */
15938 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
15940 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15942 complaint (&symfile_complaints
,
15943 _("DW_AT_low_pc %s is zero "
15944 "for DIE at 0x%x [in module %s]"),
15945 paddress (gdbarch
, part_die
->lowpc
),
15946 part_die
->offset
.sect_off
, objfile_name (objfile
));
15948 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15949 else if (part_die
->lowpc
>= part_die
->highpc
)
15951 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15953 complaint (&symfile_complaints
,
15954 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15955 "for DIE at 0x%x [in module %s]"),
15956 paddress (gdbarch
, part_die
->lowpc
),
15957 paddress (gdbarch
, part_die
->highpc
),
15958 part_die
->offset
.sect_off
, objfile_name (objfile
));
15961 part_die
->has_pc_info
= 1;
15967 /* Find a cached partial DIE at OFFSET in CU. */
15969 static struct partial_die_info
*
15970 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
15972 struct partial_die_info
*lookup_die
= NULL
;
15973 struct partial_die_info part_die
;
15975 part_die
.offset
= offset
;
15976 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
15982 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15983 except in the case of .debug_types DIEs which do not reference
15984 outside their CU (they do however referencing other types via
15985 DW_FORM_ref_sig8). */
15987 static struct partial_die_info
*
15988 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
15990 struct objfile
*objfile
= cu
->objfile
;
15991 struct dwarf2_per_cu_data
*per_cu
= NULL
;
15992 struct partial_die_info
*pd
= NULL
;
15994 if (offset_in_dwz
== cu
->per_cu
->is_dwz
15995 && offset_in_cu_p (&cu
->header
, offset
))
15997 pd
= find_partial_die_in_comp_unit (offset
, cu
);
16000 /* We missed recording what we needed.
16001 Load all dies and try again. */
16002 per_cu
= cu
->per_cu
;
16006 /* TUs don't reference other CUs/TUs (except via type signatures). */
16007 if (cu
->per_cu
->is_debug_types
)
16009 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
16010 " external reference to offset 0x%lx [in module %s].\n"),
16011 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
16012 bfd_get_filename (objfile
->obfd
));
16014 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
16017 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
16018 load_partial_comp_unit (per_cu
);
16020 per_cu
->cu
->last_used
= 0;
16021 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16024 /* If we didn't find it, and not all dies have been loaded,
16025 load them all and try again. */
16027 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
16029 per_cu
->load_all_dies
= 1;
16031 /* This is nasty. When we reread the DIEs, somewhere up the call chain
16032 THIS_CU->cu may already be in use. So we can't just free it and
16033 replace its DIEs with the ones we read in. Instead, we leave those
16034 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
16035 and clobber THIS_CU->cu->partial_dies with the hash table for the new
16037 load_partial_comp_unit (per_cu
);
16039 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16043 internal_error (__FILE__
, __LINE__
,
16044 _("could not find partial DIE 0x%x "
16045 "in cache [from module %s]\n"),
16046 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
16050 /* See if we can figure out if the class lives in a namespace. We do
16051 this by looking for a member function; its demangled name will
16052 contain namespace info, if there is any. */
16055 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
16056 struct dwarf2_cu
*cu
)
16058 /* NOTE: carlton/2003-10-07: Getting the info this way changes
16059 what template types look like, because the demangler
16060 frequently doesn't give the same name as the debug info. We
16061 could fix this by only using the demangled name to get the
16062 prefix (but see comment in read_structure_type). */
16064 struct partial_die_info
*real_pdi
;
16065 struct partial_die_info
*child_pdi
;
16067 /* If this DIE (this DIE's specification, if any) has a parent, then
16068 we should not do this. We'll prepend the parent's fully qualified
16069 name when we create the partial symbol. */
16071 real_pdi
= struct_pdi
;
16072 while (real_pdi
->has_specification
)
16073 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
16074 real_pdi
->spec_is_dwz
, cu
);
16076 if (real_pdi
->die_parent
!= NULL
)
16079 for (child_pdi
= struct_pdi
->die_child
;
16081 child_pdi
= child_pdi
->die_sibling
)
16083 if (child_pdi
->tag
== DW_TAG_subprogram
16084 && child_pdi
->linkage_name
!= NULL
)
16086 char *actual_class_name
16087 = language_class_name_from_physname (cu
->language_defn
,
16088 child_pdi
->linkage_name
);
16089 if (actual_class_name
!= NULL
)
16092 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16094 strlen (actual_class_name
));
16095 xfree (actual_class_name
);
16102 /* Adjust PART_DIE before generating a symbol for it. This function
16103 may set the is_external flag or change the DIE's name. */
16106 fixup_partial_die (struct partial_die_info
*part_die
,
16107 struct dwarf2_cu
*cu
)
16109 /* Once we've fixed up a die, there's no point in doing so again.
16110 This also avoids a memory leak if we were to call
16111 guess_partial_die_structure_name multiple times. */
16112 if (part_die
->fixup_called
)
16115 /* If we found a reference attribute and the DIE has no name, try
16116 to find a name in the referred to DIE. */
16118 if (part_die
->name
== NULL
&& part_die
->has_specification
)
16120 struct partial_die_info
*spec_die
;
16122 spec_die
= find_partial_die (part_die
->spec_offset
,
16123 part_die
->spec_is_dwz
, cu
);
16125 fixup_partial_die (spec_die
, cu
);
16127 if (spec_die
->name
)
16129 part_die
->name
= spec_die
->name
;
16131 /* Copy DW_AT_external attribute if it is set. */
16132 if (spec_die
->is_external
)
16133 part_die
->is_external
= spec_die
->is_external
;
16137 /* Set default names for some unnamed DIEs. */
16139 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
16140 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
16142 /* If there is no parent die to provide a namespace, and there are
16143 children, see if we can determine the namespace from their linkage
16145 if (cu
->language
== language_cplus
16146 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
16147 && part_die
->die_parent
== NULL
16148 && part_die
->has_children
16149 && (part_die
->tag
== DW_TAG_class_type
16150 || part_die
->tag
== DW_TAG_structure_type
16151 || part_die
->tag
== DW_TAG_union_type
))
16152 guess_partial_die_structure_name (part_die
, cu
);
16154 /* GCC might emit a nameless struct or union that has a linkage
16155 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16156 if (part_die
->name
== NULL
16157 && (part_die
->tag
== DW_TAG_class_type
16158 || part_die
->tag
== DW_TAG_interface_type
16159 || part_die
->tag
== DW_TAG_structure_type
16160 || part_die
->tag
== DW_TAG_union_type
)
16161 && part_die
->linkage_name
!= NULL
)
16165 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
16170 /* Strip any leading namespaces/classes, keep only the base name.
16171 DW_AT_name for named DIEs does not contain the prefixes. */
16172 base
= strrchr (demangled
, ':');
16173 if (base
&& base
> demangled
&& base
[-1] == ':')
16179 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16180 base
, strlen (base
));
16185 part_die
->fixup_called
= 1;
16188 /* Read an attribute value described by an attribute form. */
16190 static const gdb_byte
*
16191 read_attribute_value (const struct die_reader_specs
*reader
,
16192 struct attribute
*attr
, unsigned form
,
16193 const gdb_byte
*info_ptr
)
16195 struct dwarf2_cu
*cu
= reader
->cu
;
16196 struct objfile
*objfile
= cu
->objfile
;
16197 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16198 bfd
*abfd
= reader
->abfd
;
16199 struct comp_unit_head
*cu_header
= &cu
->header
;
16200 unsigned int bytes_read
;
16201 struct dwarf_block
*blk
;
16206 case DW_FORM_ref_addr
:
16207 if (cu
->header
.version
== 2)
16208 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16210 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
16211 &cu
->header
, &bytes_read
);
16212 info_ptr
+= bytes_read
;
16214 case DW_FORM_GNU_ref_alt
:
16215 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16216 info_ptr
+= bytes_read
;
16219 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16220 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
16221 info_ptr
+= bytes_read
;
16223 case DW_FORM_block2
:
16224 blk
= dwarf_alloc_block (cu
);
16225 blk
->size
= read_2_bytes (abfd
, info_ptr
);
16227 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16228 info_ptr
+= blk
->size
;
16229 DW_BLOCK (attr
) = blk
;
16231 case DW_FORM_block4
:
16232 blk
= dwarf_alloc_block (cu
);
16233 blk
->size
= read_4_bytes (abfd
, info_ptr
);
16235 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16236 info_ptr
+= blk
->size
;
16237 DW_BLOCK (attr
) = blk
;
16239 case DW_FORM_data2
:
16240 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
16243 case DW_FORM_data4
:
16244 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
16247 case DW_FORM_data8
:
16248 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
16251 case DW_FORM_sec_offset
:
16252 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16253 info_ptr
+= bytes_read
;
16255 case DW_FORM_string
:
16256 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
16257 DW_STRING_IS_CANONICAL (attr
) = 0;
16258 info_ptr
+= bytes_read
;
16261 if (!cu
->per_cu
->is_dwz
)
16263 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
16265 DW_STRING_IS_CANONICAL (attr
) = 0;
16266 info_ptr
+= bytes_read
;
16270 case DW_FORM_GNU_strp_alt
:
16272 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
16273 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
16276 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
16277 DW_STRING_IS_CANONICAL (attr
) = 0;
16278 info_ptr
+= bytes_read
;
16281 case DW_FORM_exprloc
:
16282 case DW_FORM_block
:
16283 blk
= dwarf_alloc_block (cu
);
16284 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16285 info_ptr
+= bytes_read
;
16286 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16287 info_ptr
+= blk
->size
;
16288 DW_BLOCK (attr
) = blk
;
16290 case DW_FORM_block1
:
16291 blk
= dwarf_alloc_block (cu
);
16292 blk
->size
= read_1_byte (abfd
, info_ptr
);
16294 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16295 info_ptr
+= blk
->size
;
16296 DW_BLOCK (attr
) = blk
;
16298 case DW_FORM_data1
:
16299 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16303 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16306 case DW_FORM_flag_present
:
16307 DW_UNSND (attr
) = 1;
16309 case DW_FORM_sdata
:
16310 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
16311 info_ptr
+= bytes_read
;
16313 case DW_FORM_udata
:
16314 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16315 info_ptr
+= bytes_read
;
16318 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16319 + read_1_byte (abfd
, info_ptr
));
16323 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16324 + read_2_bytes (abfd
, info_ptr
));
16328 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16329 + read_4_bytes (abfd
, info_ptr
));
16333 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16334 + read_8_bytes (abfd
, info_ptr
));
16337 case DW_FORM_ref_sig8
:
16338 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
16341 case DW_FORM_ref_udata
:
16342 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16343 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
16344 info_ptr
+= bytes_read
;
16346 case DW_FORM_indirect
:
16347 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16348 info_ptr
+= bytes_read
;
16349 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
16351 case DW_FORM_GNU_addr_index
:
16352 if (reader
->dwo_file
== NULL
)
16354 /* For now flag a hard error.
16355 Later we can turn this into a complaint. */
16356 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16357 dwarf_form_name (form
),
16358 bfd_get_filename (abfd
));
16360 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
16361 info_ptr
+= bytes_read
;
16363 case DW_FORM_GNU_str_index
:
16364 if (reader
->dwo_file
== NULL
)
16366 /* For now flag a hard error.
16367 Later we can turn this into a complaint if warranted. */
16368 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16369 dwarf_form_name (form
),
16370 bfd_get_filename (abfd
));
16373 ULONGEST str_index
=
16374 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16376 DW_STRING (attr
) = read_str_index (reader
, str_index
);
16377 DW_STRING_IS_CANONICAL (attr
) = 0;
16378 info_ptr
+= bytes_read
;
16382 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16383 dwarf_form_name (form
),
16384 bfd_get_filename (abfd
));
16388 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
16389 attr
->form
= DW_FORM_GNU_ref_alt
;
16391 /* We have seen instances where the compiler tried to emit a byte
16392 size attribute of -1 which ended up being encoded as an unsigned
16393 0xffffffff. Although 0xffffffff is technically a valid size value,
16394 an object of this size seems pretty unlikely so we can relatively
16395 safely treat these cases as if the size attribute was invalid and
16396 treat them as zero by default. */
16397 if (attr
->name
== DW_AT_byte_size
16398 && form
== DW_FORM_data4
16399 && DW_UNSND (attr
) >= 0xffffffff)
16402 (&symfile_complaints
,
16403 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16404 hex_string (DW_UNSND (attr
)));
16405 DW_UNSND (attr
) = 0;
16411 /* Read an attribute described by an abbreviated attribute. */
16413 static const gdb_byte
*
16414 read_attribute (const struct die_reader_specs
*reader
,
16415 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
16416 const gdb_byte
*info_ptr
)
16418 attr
->name
= abbrev
->name
;
16419 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
16422 /* Read dwarf information from a buffer. */
16424 static unsigned int
16425 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
16427 return bfd_get_8 (abfd
, buf
);
16431 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
16433 return bfd_get_signed_8 (abfd
, buf
);
16436 static unsigned int
16437 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16439 return bfd_get_16 (abfd
, buf
);
16443 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16445 return bfd_get_signed_16 (abfd
, buf
);
16448 static unsigned int
16449 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16451 return bfd_get_32 (abfd
, buf
);
16455 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16457 return bfd_get_signed_32 (abfd
, buf
);
16461 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16463 return bfd_get_64 (abfd
, buf
);
16467 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
16468 unsigned int *bytes_read
)
16470 struct comp_unit_head
*cu_header
= &cu
->header
;
16471 CORE_ADDR retval
= 0;
16473 if (cu_header
->signed_addr_p
)
16475 switch (cu_header
->addr_size
)
16478 retval
= bfd_get_signed_16 (abfd
, buf
);
16481 retval
= bfd_get_signed_32 (abfd
, buf
);
16484 retval
= bfd_get_signed_64 (abfd
, buf
);
16487 internal_error (__FILE__
, __LINE__
,
16488 _("read_address: bad switch, signed [in module %s]"),
16489 bfd_get_filename (abfd
));
16494 switch (cu_header
->addr_size
)
16497 retval
= bfd_get_16 (abfd
, buf
);
16500 retval
= bfd_get_32 (abfd
, buf
);
16503 retval
= bfd_get_64 (abfd
, buf
);
16506 internal_error (__FILE__
, __LINE__
,
16507 _("read_address: bad switch, "
16508 "unsigned [in module %s]"),
16509 bfd_get_filename (abfd
));
16513 *bytes_read
= cu_header
->addr_size
;
16517 /* Read the initial length from a section. The (draft) DWARF 3
16518 specification allows the initial length to take up either 4 bytes
16519 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16520 bytes describe the length and all offsets will be 8 bytes in length
16523 An older, non-standard 64-bit format is also handled by this
16524 function. The older format in question stores the initial length
16525 as an 8-byte quantity without an escape value. Lengths greater
16526 than 2^32 aren't very common which means that the initial 4 bytes
16527 is almost always zero. Since a length value of zero doesn't make
16528 sense for the 32-bit format, this initial zero can be considered to
16529 be an escape value which indicates the presence of the older 64-bit
16530 format. As written, the code can't detect (old format) lengths
16531 greater than 4GB. If it becomes necessary to handle lengths
16532 somewhat larger than 4GB, we could allow other small values (such
16533 as the non-sensical values of 1, 2, and 3) to also be used as
16534 escape values indicating the presence of the old format.
16536 The value returned via bytes_read should be used to increment the
16537 relevant pointer after calling read_initial_length().
16539 [ Note: read_initial_length() and read_offset() are based on the
16540 document entitled "DWARF Debugging Information Format", revision
16541 3, draft 8, dated November 19, 2001. This document was obtained
16544 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16546 This document is only a draft and is subject to change. (So beware.)
16548 Details regarding the older, non-standard 64-bit format were
16549 determined empirically by examining 64-bit ELF files produced by
16550 the SGI toolchain on an IRIX 6.5 machine.
16552 - Kevin, July 16, 2002
16556 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
16558 LONGEST length
= bfd_get_32 (abfd
, buf
);
16560 if (length
== 0xffffffff)
16562 length
= bfd_get_64 (abfd
, buf
+ 4);
16565 else if (length
== 0)
16567 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16568 length
= bfd_get_64 (abfd
, buf
);
16579 /* Cover function for read_initial_length.
16580 Returns the length of the object at BUF, and stores the size of the
16581 initial length in *BYTES_READ and stores the size that offsets will be in
16583 If the initial length size is not equivalent to that specified in
16584 CU_HEADER then issue a complaint.
16585 This is useful when reading non-comp-unit headers. */
16588 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
16589 const struct comp_unit_head
*cu_header
,
16590 unsigned int *bytes_read
,
16591 unsigned int *offset_size
)
16593 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
16595 gdb_assert (cu_header
->initial_length_size
== 4
16596 || cu_header
->initial_length_size
== 8
16597 || cu_header
->initial_length_size
== 12);
16599 if (cu_header
->initial_length_size
!= *bytes_read
)
16600 complaint (&symfile_complaints
,
16601 _("intermixed 32-bit and 64-bit DWARF sections"));
16603 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
16607 /* Read an offset from the data stream. The size of the offset is
16608 given by cu_header->offset_size. */
16611 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
16612 const struct comp_unit_head
*cu_header
,
16613 unsigned int *bytes_read
)
16615 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
16617 *bytes_read
= cu_header
->offset_size
;
16621 /* Read an offset from the data stream. */
16624 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
16626 LONGEST retval
= 0;
16628 switch (offset_size
)
16631 retval
= bfd_get_32 (abfd
, buf
);
16634 retval
= bfd_get_64 (abfd
, buf
);
16637 internal_error (__FILE__
, __LINE__
,
16638 _("read_offset_1: bad switch [in module %s]"),
16639 bfd_get_filename (abfd
));
16645 static const gdb_byte
*
16646 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
16648 /* If the size of a host char is 8 bits, we can return a pointer
16649 to the buffer, otherwise we have to copy the data to a buffer
16650 allocated on the temporary obstack. */
16651 gdb_assert (HOST_CHAR_BIT
== 8);
16655 static const char *
16656 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
16657 unsigned int *bytes_read_ptr
)
16659 /* If the size of a host char is 8 bits, we can return a pointer
16660 to the string, otherwise we have to copy the string to a buffer
16661 allocated on the temporary obstack. */
16662 gdb_assert (HOST_CHAR_BIT
== 8);
16665 *bytes_read_ptr
= 1;
16668 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
16669 return (const char *) buf
;
16672 static const char *
16673 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
16675 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
16676 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
16677 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16678 bfd_get_filename (abfd
));
16679 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
16680 error (_("DW_FORM_strp pointing outside of "
16681 ".debug_str section [in module %s]"),
16682 bfd_get_filename (abfd
));
16683 gdb_assert (HOST_CHAR_BIT
== 8);
16684 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
16686 return (const char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
16689 /* Read a string at offset STR_OFFSET in the .debug_str section from
16690 the .dwz file DWZ. Throw an error if the offset is too large. If
16691 the string consists of a single NUL byte, return NULL; otherwise
16692 return a pointer to the string. */
16694 static const char *
16695 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
16697 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
16699 if (dwz
->str
.buffer
== NULL
)
16700 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16701 "section [in module %s]"),
16702 bfd_get_filename (dwz
->dwz_bfd
));
16703 if (str_offset
>= dwz
->str
.size
)
16704 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16705 ".debug_str section [in module %s]"),
16706 bfd_get_filename (dwz
->dwz_bfd
));
16707 gdb_assert (HOST_CHAR_BIT
== 8);
16708 if (dwz
->str
.buffer
[str_offset
] == '\0')
16710 return (const char *) (dwz
->str
.buffer
+ str_offset
);
16713 static const char *
16714 read_indirect_string (bfd
*abfd
, const gdb_byte
*buf
,
16715 const struct comp_unit_head
*cu_header
,
16716 unsigned int *bytes_read_ptr
)
16718 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
16720 return read_indirect_string_at_offset (abfd
, str_offset
);
16724 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16725 unsigned int *bytes_read_ptr
)
16728 unsigned int num_read
;
16730 unsigned char byte
;
16738 byte
= bfd_get_8 (abfd
, buf
);
16741 result
|= ((ULONGEST
) (byte
& 127) << shift
);
16742 if ((byte
& 128) == 0)
16748 *bytes_read_ptr
= num_read
;
16753 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16754 unsigned int *bytes_read_ptr
)
16757 int i
, shift
, num_read
;
16758 unsigned char byte
;
16766 byte
= bfd_get_8 (abfd
, buf
);
16769 result
|= ((LONGEST
) (byte
& 127) << shift
);
16771 if ((byte
& 128) == 0)
16776 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
16777 result
|= -(((LONGEST
) 1) << shift
);
16778 *bytes_read_ptr
= num_read
;
16782 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16783 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16784 ADDR_SIZE is the size of addresses from the CU header. */
16787 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
16789 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16790 bfd
*abfd
= objfile
->obfd
;
16791 const gdb_byte
*info_ptr
;
16793 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
16794 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
16795 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16796 objfile_name (objfile
));
16797 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
16798 error (_("DW_FORM_addr_index pointing outside of "
16799 ".debug_addr section [in module %s]"),
16800 objfile_name (objfile
));
16801 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
16802 + addr_base
+ addr_index
* addr_size
);
16803 if (addr_size
== 4)
16804 return bfd_get_32 (abfd
, info_ptr
);
16806 return bfd_get_64 (abfd
, info_ptr
);
16809 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16812 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
16814 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
16817 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16820 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
16821 unsigned int *bytes_read
)
16823 bfd
*abfd
= cu
->objfile
->obfd
;
16824 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
16826 return read_addr_index (cu
, addr_index
);
16829 /* Data structure to pass results from dwarf2_read_addr_index_reader
16830 back to dwarf2_read_addr_index. */
16832 struct dwarf2_read_addr_index_data
16834 ULONGEST addr_base
;
16838 /* die_reader_func for dwarf2_read_addr_index. */
16841 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
16842 const gdb_byte
*info_ptr
,
16843 struct die_info
*comp_unit_die
,
16847 struct dwarf2_cu
*cu
= reader
->cu
;
16848 struct dwarf2_read_addr_index_data
*aidata
=
16849 (struct dwarf2_read_addr_index_data
*) data
;
16851 aidata
->addr_base
= cu
->addr_base
;
16852 aidata
->addr_size
= cu
->header
.addr_size
;
16855 /* Given an index in .debug_addr, fetch the value.
16856 NOTE: This can be called during dwarf expression evaluation,
16857 long after the debug information has been read, and thus per_cu->cu
16858 may no longer exist. */
16861 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
16862 unsigned int addr_index
)
16864 struct objfile
*objfile
= per_cu
->objfile
;
16865 struct dwarf2_cu
*cu
= per_cu
->cu
;
16866 ULONGEST addr_base
;
16869 /* This is intended to be called from outside this file. */
16870 dw2_setup (objfile
);
16872 /* We need addr_base and addr_size.
16873 If we don't have PER_CU->cu, we have to get it.
16874 Nasty, but the alternative is storing the needed info in PER_CU,
16875 which at this point doesn't seem justified: it's not clear how frequently
16876 it would get used and it would increase the size of every PER_CU.
16877 Entry points like dwarf2_per_cu_addr_size do a similar thing
16878 so we're not in uncharted territory here.
16879 Alas we need to be a bit more complicated as addr_base is contained
16882 We don't need to read the entire CU(/TU).
16883 We just need the header and top level die.
16885 IWBN to use the aging mechanism to let us lazily later discard the CU.
16886 For now we skip this optimization. */
16890 addr_base
= cu
->addr_base
;
16891 addr_size
= cu
->header
.addr_size
;
16895 struct dwarf2_read_addr_index_data aidata
;
16897 /* Note: We can't use init_cutu_and_read_dies_simple here,
16898 we need addr_base. */
16899 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
16900 dwarf2_read_addr_index_reader
, &aidata
);
16901 addr_base
= aidata
.addr_base
;
16902 addr_size
= aidata
.addr_size
;
16905 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
16908 /* Given a DW_FORM_GNU_str_index, fetch the string.
16909 This is only used by the Fission support. */
16911 static const char *
16912 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
16914 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16915 const char *objf_name
= objfile_name (objfile
);
16916 bfd
*abfd
= objfile
->obfd
;
16917 struct dwarf2_cu
*cu
= reader
->cu
;
16918 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
16919 struct dwarf2_section_info
*str_offsets_section
=
16920 &reader
->dwo_file
->sections
.str_offsets
;
16921 const gdb_byte
*info_ptr
;
16922 ULONGEST str_offset
;
16923 static const char form_name
[] = "DW_FORM_GNU_str_index";
16925 dwarf2_read_section (objfile
, str_section
);
16926 dwarf2_read_section (objfile
, str_offsets_section
);
16927 if (str_section
->buffer
== NULL
)
16928 error (_("%s used without .debug_str.dwo section"
16929 " in CU at offset 0x%lx [in module %s]"),
16930 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16931 if (str_offsets_section
->buffer
== NULL
)
16932 error (_("%s used without .debug_str_offsets.dwo section"
16933 " in CU at offset 0x%lx [in module %s]"),
16934 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16935 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
16936 error (_("%s pointing outside of .debug_str_offsets.dwo"
16937 " section in CU at offset 0x%lx [in module %s]"),
16938 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16939 info_ptr
= (str_offsets_section
->buffer
16940 + str_index
* cu
->header
.offset_size
);
16941 if (cu
->header
.offset_size
== 4)
16942 str_offset
= bfd_get_32 (abfd
, info_ptr
);
16944 str_offset
= bfd_get_64 (abfd
, info_ptr
);
16945 if (str_offset
>= str_section
->size
)
16946 error (_("Offset from %s pointing outside of"
16947 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16948 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16949 return (const char *) (str_section
->buffer
+ str_offset
);
16952 /* Return the length of an LEB128 number in BUF. */
16955 leb128_size (const gdb_byte
*buf
)
16957 const gdb_byte
*begin
= buf
;
16963 if ((byte
& 128) == 0)
16964 return buf
- begin
;
16969 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
16978 cu
->language
= language_c
;
16980 case DW_LANG_C_plus_plus
:
16981 case DW_LANG_C_plus_plus_11
:
16982 case DW_LANG_C_plus_plus_14
:
16983 cu
->language
= language_cplus
;
16986 cu
->language
= language_d
;
16988 case DW_LANG_Fortran77
:
16989 case DW_LANG_Fortran90
:
16990 case DW_LANG_Fortran95
:
16991 case DW_LANG_Fortran03
:
16992 case DW_LANG_Fortran08
:
16993 cu
->language
= language_fortran
;
16996 cu
->language
= language_go
;
16998 case DW_LANG_Mips_Assembler
:
16999 cu
->language
= language_asm
;
17002 cu
->language
= language_java
;
17004 case DW_LANG_Ada83
:
17005 case DW_LANG_Ada95
:
17006 cu
->language
= language_ada
;
17008 case DW_LANG_Modula2
:
17009 cu
->language
= language_m2
;
17011 case DW_LANG_Pascal83
:
17012 cu
->language
= language_pascal
;
17015 cu
->language
= language_objc
;
17017 case DW_LANG_Cobol74
:
17018 case DW_LANG_Cobol85
:
17020 cu
->language
= language_minimal
;
17023 cu
->language_defn
= language_def (cu
->language
);
17026 /* Return the named attribute or NULL if not there. */
17028 static struct attribute
*
17029 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
17034 struct attribute
*spec
= NULL
;
17036 for (i
= 0; i
< die
->num_attrs
; ++i
)
17038 if (die
->attrs
[i
].name
== name
)
17039 return &die
->attrs
[i
];
17040 if (die
->attrs
[i
].name
== DW_AT_specification
17041 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
17042 spec
= &die
->attrs
[i
];
17048 die
= follow_die_ref (die
, spec
, &cu
);
17054 /* Return the named attribute or NULL if not there,
17055 but do not follow DW_AT_specification, etc.
17056 This is for use in contexts where we're reading .debug_types dies.
17057 Following DW_AT_specification, DW_AT_abstract_origin will take us
17058 back up the chain, and we want to go down. */
17060 static struct attribute
*
17061 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
17065 for (i
= 0; i
< die
->num_attrs
; ++i
)
17066 if (die
->attrs
[i
].name
== name
)
17067 return &die
->attrs
[i
];
17072 /* Return non-zero iff the attribute NAME is defined for the given DIE,
17073 and holds a non-zero value. This function should only be used for
17074 DW_FORM_flag or DW_FORM_flag_present attributes. */
17077 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
17079 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
17081 return (attr
&& DW_UNSND (attr
));
17085 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
17087 /* A DIE is a declaration if it has a DW_AT_declaration attribute
17088 which value is non-zero. However, we have to be careful with
17089 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
17090 (via dwarf2_flag_true_p) follows this attribute. So we may
17091 end up accidently finding a declaration attribute that belongs
17092 to a different DIE referenced by the specification attribute,
17093 even though the given DIE does not have a declaration attribute. */
17094 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
17095 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
17098 /* Return the die giving the specification for DIE, if there is
17099 one. *SPEC_CU is the CU containing DIE on input, and the CU
17100 containing the return value on output. If there is no
17101 specification, but there is an abstract origin, that is
17104 static struct die_info
*
17105 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
17107 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
17110 if (spec_attr
== NULL
)
17111 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
17113 if (spec_attr
== NULL
)
17116 return follow_die_ref (die
, spec_attr
, spec_cu
);
17119 /* Free the line_header structure *LH, and any arrays and strings it
17121 NOTE: This is also used as a "cleanup" function. */
17124 free_line_header (struct line_header
*lh
)
17126 if (lh
->standard_opcode_lengths
)
17127 xfree (lh
->standard_opcode_lengths
);
17129 /* Remember that all the lh->file_names[i].name pointers are
17130 pointers into debug_line_buffer, and don't need to be freed. */
17131 if (lh
->file_names
)
17132 xfree (lh
->file_names
);
17134 /* Similarly for the include directory names. */
17135 if (lh
->include_dirs
)
17136 xfree (lh
->include_dirs
);
17141 /* Stub for free_line_header to match void * callback types. */
17144 free_line_header_voidp (void *arg
)
17146 struct line_header
*lh
= arg
;
17148 free_line_header (lh
);
17151 /* Add an entry to LH's include directory table. */
17154 add_include_dir (struct line_header
*lh
, const char *include_dir
)
17156 if (dwarf_line_debug
>= 2)
17157 fprintf_unfiltered (gdb_stdlog
, "Adding dir %u: %s\n",
17158 lh
->num_include_dirs
+ 1, include_dir
);
17160 /* Grow the array if necessary. */
17161 if (lh
->include_dirs_size
== 0)
17163 lh
->include_dirs_size
= 1; /* for testing */
17164 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
17165 * sizeof (*lh
->include_dirs
));
17167 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
17169 lh
->include_dirs_size
*= 2;
17170 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
17171 (lh
->include_dirs_size
17172 * sizeof (*lh
->include_dirs
)));
17175 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
17178 /* Add an entry to LH's file name table. */
17181 add_file_name (struct line_header
*lh
,
17183 unsigned int dir_index
,
17184 unsigned int mod_time
,
17185 unsigned int length
)
17187 struct file_entry
*fe
;
17189 if (dwarf_line_debug
>= 2)
17190 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
17191 lh
->num_file_names
+ 1, name
);
17193 /* Grow the array if necessary. */
17194 if (lh
->file_names_size
== 0)
17196 lh
->file_names_size
= 1; /* for testing */
17197 lh
->file_names
= xmalloc (lh
->file_names_size
17198 * sizeof (*lh
->file_names
));
17200 else if (lh
->num_file_names
>= lh
->file_names_size
)
17202 lh
->file_names_size
*= 2;
17203 lh
->file_names
= xrealloc (lh
->file_names
,
17204 (lh
->file_names_size
17205 * sizeof (*lh
->file_names
)));
17208 fe
= &lh
->file_names
[lh
->num_file_names
++];
17210 fe
->dir_index
= dir_index
;
17211 fe
->mod_time
= mod_time
;
17212 fe
->length
= length
;
17213 fe
->included_p
= 0;
17217 /* A convenience function to find the proper .debug_line section for a CU. */
17219 static struct dwarf2_section_info
*
17220 get_debug_line_section (struct dwarf2_cu
*cu
)
17222 struct dwarf2_section_info
*section
;
17224 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
17226 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17227 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
17228 else if (cu
->per_cu
->is_dwz
)
17230 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17232 section
= &dwz
->line
;
17235 section
= &dwarf2_per_objfile
->line
;
17240 /* Read the statement program header starting at OFFSET in
17241 .debug_line, or .debug_line.dwo. Return a pointer
17242 to a struct line_header, allocated using xmalloc.
17243 Returns NULL if there is a problem reading the header, e.g., if it
17244 has a version we don't understand.
17246 NOTE: the strings in the include directory and file name tables of
17247 the returned object point into the dwarf line section buffer,
17248 and must not be freed. */
17250 static struct line_header
*
17251 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
17253 struct cleanup
*back_to
;
17254 struct line_header
*lh
;
17255 const gdb_byte
*line_ptr
;
17256 unsigned int bytes_read
, offset_size
;
17258 const char *cur_dir
, *cur_file
;
17259 struct dwarf2_section_info
*section
;
17262 section
= get_debug_line_section (cu
);
17263 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
17264 if (section
->buffer
== NULL
)
17266 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17267 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
17269 complaint (&symfile_complaints
, _("missing .debug_line section"));
17273 /* We can't do this until we know the section is non-empty.
17274 Only then do we know we have such a section. */
17275 abfd
= get_section_bfd_owner (section
);
17277 /* Make sure that at least there's room for the total_length field.
17278 That could be 12 bytes long, but we're just going to fudge that. */
17279 if (offset
+ 4 >= section
->size
)
17281 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17285 lh
= xmalloc (sizeof (*lh
));
17286 memset (lh
, 0, sizeof (*lh
));
17287 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
17290 lh
->offset
.sect_off
= offset
;
17291 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
17293 line_ptr
= section
->buffer
+ offset
;
17295 /* Read in the header. */
17297 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
17298 &bytes_read
, &offset_size
);
17299 line_ptr
+= bytes_read
;
17300 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
17302 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17303 do_cleanups (back_to
);
17306 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
17307 lh
->version
= read_2_bytes (abfd
, line_ptr
);
17309 if (lh
->version
> 4)
17311 /* This is a version we don't understand. The format could have
17312 changed in ways we don't handle properly so just punt. */
17313 complaint (&symfile_complaints
,
17314 _("unsupported version in .debug_line section"));
17317 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
17318 line_ptr
+= offset_size
;
17319 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
17321 if (lh
->version
>= 4)
17323 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
17327 lh
->maximum_ops_per_instruction
= 1;
17329 if (lh
->maximum_ops_per_instruction
== 0)
17331 lh
->maximum_ops_per_instruction
= 1;
17332 complaint (&symfile_complaints
,
17333 _("invalid maximum_ops_per_instruction "
17334 "in `.debug_line' section"));
17337 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
17339 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
17341 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
17343 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
17345 lh
->standard_opcode_lengths
17346 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
17348 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
17349 for (i
= 1; i
< lh
->opcode_base
; ++i
)
17351 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
17355 /* Read directory table. */
17356 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17358 line_ptr
+= bytes_read
;
17359 add_include_dir (lh
, cur_dir
);
17361 line_ptr
+= bytes_read
;
17363 /* Read file name table. */
17364 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17366 unsigned int dir_index
, mod_time
, length
;
17368 line_ptr
+= bytes_read
;
17369 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17370 line_ptr
+= bytes_read
;
17371 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17372 line_ptr
+= bytes_read
;
17373 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17374 line_ptr
+= bytes_read
;
17376 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17378 line_ptr
+= bytes_read
;
17379 lh
->statement_program_start
= line_ptr
;
17381 if (line_ptr
> (section
->buffer
+ section
->size
))
17382 complaint (&symfile_complaints
,
17383 _("line number info header doesn't "
17384 "fit in `.debug_line' section"));
17386 discard_cleanups (back_to
);
17390 /* Subroutine of dwarf_decode_lines to simplify it.
17391 Return the file name of the psymtab for included file FILE_INDEX
17392 in line header LH of PST.
17393 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17394 If space for the result is malloc'd, it will be freed by a cleanup.
17395 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17397 The function creates dangling cleanup registration. */
17399 static const char *
17400 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
17401 const struct partial_symtab
*pst
,
17402 const char *comp_dir
)
17404 const struct file_entry fe
= lh
->file_names
[file_index
];
17405 const char *include_name
= fe
.name
;
17406 const char *include_name_to_compare
= include_name
;
17407 const char *dir_name
= NULL
;
17408 const char *pst_filename
;
17409 char *copied_name
= NULL
;
17412 if (fe
.dir_index
&& lh
->include_dirs
!= NULL
)
17413 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
17415 if (!IS_ABSOLUTE_PATH (include_name
)
17416 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
17418 /* Avoid creating a duplicate psymtab for PST.
17419 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17420 Before we do the comparison, however, we need to account
17421 for DIR_NAME and COMP_DIR.
17422 First prepend dir_name (if non-NULL). If we still don't
17423 have an absolute path prepend comp_dir (if non-NULL).
17424 However, the directory we record in the include-file's
17425 psymtab does not contain COMP_DIR (to match the
17426 corresponding symtab(s)).
17431 bash$ gcc -g ./hello.c
17432 include_name = "hello.c"
17434 DW_AT_comp_dir = comp_dir = "/tmp"
17435 DW_AT_name = "./hello.c"
17439 if (dir_name
!= NULL
)
17441 char *tem
= concat (dir_name
, SLASH_STRING
,
17442 include_name
, (char *)NULL
);
17444 make_cleanup (xfree
, tem
);
17445 include_name
= tem
;
17446 include_name_to_compare
= include_name
;
17448 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
17450 char *tem
= concat (comp_dir
, SLASH_STRING
,
17451 include_name
, (char *)NULL
);
17453 make_cleanup (xfree
, tem
);
17454 include_name_to_compare
= tem
;
17458 pst_filename
= pst
->filename
;
17459 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
17461 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
17462 pst_filename
, (char *)NULL
);
17463 pst_filename
= copied_name
;
17466 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
17468 if (copied_name
!= NULL
)
17469 xfree (copied_name
);
17473 return include_name
;
17476 /* State machine to track the state of the line number program. */
17480 /* These are part of the standard DWARF line number state machine. */
17482 unsigned char op_index
;
17487 unsigned int discriminator
;
17489 /* Additional bits of state we need to track. */
17491 /* The last file that we called dwarf2_start_subfile for.
17492 This is only used for TLLs. */
17493 unsigned int last_file
;
17494 /* The last file a line number was recorded for. */
17495 struct subfile
*last_subfile
;
17497 /* The function to call to record a line. */
17498 record_line_ftype
*record_line
;
17500 /* The last line number that was recorded, used to coalesce
17501 consecutive entries for the same line. This can happen, for
17502 example, when discriminators are present. PR 17276. */
17503 unsigned int last_line
;
17504 int line_has_non_zero_discriminator
;
17505 } lnp_state_machine
;
17507 /* There's a lot of static state to pass to dwarf_record_line.
17508 This keeps it all together. */
17513 struct gdbarch
*gdbarch
;
17515 /* The line number header. */
17516 struct line_header
*line_header
;
17518 /* Non-zero if we're recording lines.
17519 Otherwise we're building partial symtabs and are just interested in
17520 finding include files mentioned by the line number program. */
17521 int record_lines_p
;
17522 } lnp_reader_state
;
17524 /* Ignore this record_line request. */
17527 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17532 /* Return non-zero if we should add LINE to the line number table.
17533 LINE is the line to add, LAST_LINE is the last line that was added,
17534 LAST_SUBFILE is the subfile for LAST_LINE.
17535 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17536 had a non-zero discriminator.
17538 We have to be careful in the presence of discriminators.
17539 E.g., for this line:
17541 for (i = 0; i < 100000; i++);
17543 clang can emit four line number entries for that one line,
17544 each with a different discriminator.
17545 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17547 However, we want gdb to coalesce all four entries into one.
17548 Otherwise the user could stepi into the middle of the line and
17549 gdb would get confused about whether the pc really was in the
17550 middle of the line.
17552 Things are further complicated by the fact that two consecutive
17553 line number entries for the same line is a heuristic used by gcc
17554 to denote the end of the prologue. So we can't just discard duplicate
17555 entries, we have to be selective about it. The heuristic we use is
17556 that we only collapse consecutive entries for the same line if at least
17557 one of those entries has a non-zero discriminator. PR 17276.
17559 Note: Addresses in the line number state machine can never go backwards
17560 within one sequence, thus this coalescing is ok. */
17563 dwarf_record_line_p (unsigned int line
, unsigned int last_line
,
17564 int line_has_non_zero_discriminator
,
17565 struct subfile
*last_subfile
)
17567 if (current_subfile
!= last_subfile
)
17569 if (line
!= last_line
)
17571 /* Same line for the same file that we've seen already.
17572 As a last check, for pr 17276, only record the line if the line
17573 has never had a non-zero discriminator. */
17574 if (!line_has_non_zero_discriminator
)
17579 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17580 in the line table of subfile SUBFILE. */
17583 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17584 unsigned int line
, CORE_ADDR address
,
17585 record_line_ftype p_record_line
)
17587 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17589 if (dwarf_line_debug
)
17591 fprintf_unfiltered (gdb_stdlog
,
17592 "Recording line %u, file %s, address %s\n",
17593 line
, lbasename (subfile
->name
),
17594 paddress (gdbarch
, address
));
17597 (*p_record_line
) (subfile
, line
, addr
);
17600 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17601 Mark the end of a set of line number records.
17602 The arguments are the same as for dwarf_record_line_1.
17603 If SUBFILE is NULL the request is ignored. */
17606 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17607 CORE_ADDR address
, record_line_ftype p_record_line
)
17609 if (subfile
== NULL
)
17612 if (dwarf_line_debug
)
17614 fprintf_unfiltered (gdb_stdlog
,
17615 "Finishing current line, file %s, address %s\n",
17616 lbasename (subfile
->name
),
17617 paddress (gdbarch
, address
));
17620 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, p_record_line
);
17623 /* Record the line in STATE.
17624 END_SEQUENCE is non-zero if we're processing the end of a sequence. */
17627 dwarf_record_line (lnp_reader_state
*reader
, lnp_state_machine
*state
,
17630 const struct line_header
*lh
= reader
->line_header
;
17631 unsigned int file
, line
, discriminator
;
17634 file
= state
->file
;
17635 line
= state
->line
;
17636 is_stmt
= state
->is_stmt
;
17637 discriminator
= state
->discriminator
;
17639 if (dwarf_line_debug
)
17641 fprintf_unfiltered (gdb_stdlog
,
17642 "Processing actual line %u: file %u,"
17643 " address %s, is_stmt %u, discrim %u\n",
17645 paddress (reader
->gdbarch
, state
->address
),
17646 is_stmt
, discriminator
);
17649 if (file
== 0 || file
- 1 >= lh
->num_file_names
)
17650 dwarf2_debug_line_missing_file_complaint ();
17651 /* For now we ignore lines not starting on an instruction boundary.
17652 But not when processing end_sequence for compatibility with the
17653 previous version of the code. */
17654 else if (state
->op_index
== 0 || end_sequence
)
17656 lh
->file_names
[file
- 1].included_p
= 1;
17657 if (reader
->record_lines_p
&& is_stmt
)
17659 if (state
->last_subfile
!= current_subfile
|| end_sequence
)
17661 dwarf_finish_line (reader
->gdbarch
, state
->last_subfile
,
17662 state
->address
, state
->record_line
);
17667 if (dwarf_record_line_p (line
, state
->last_line
,
17668 state
->line_has_non_zero_discriminator
,
17669 state
->last_subfile
))
17671 dwarf_record_line_1 (reader
->gdbarch
, current_subfile
,
17672 line
, state
->address
,
17673 state
->record_line
);
17675 state
->last_subfile
= current_subfile
;
17676 state
->last_line
= line
;
17682 /* Initialize STATE for the start of a line number program. */
17685 init_lnp_state_machine (lnp_state_machine
*state
,
17686 const lnp_reader_state
*reader
)
17688 memset (state
, 0, sizeof (*state
));
17690 /* Just starting, there is no "last file". */
17691 state
->last_file
= 0;
17692 state
->last_subfile
= NULL
;
17694 state
->record_line
= record_line
;
17696 state
->last_line
= 0;
17697 state
->line_has_non_zero_discriminator
= 0;
17699 /* Initialize these according to the DWARF spec. */
17700 state
->op_index
= 0;
17703 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
17704 was a line entry for it so that the backend has a chance to adjust it
17705 and also record it in case it needs it. This is currently used by MIPS
17706 code, cf. `mips_adjust_dwarf2_line'. */
17707 state
->address
= gdbarch_adjust_dwarf2_line (reader
->gdbarch
, 0, 0);
17708 state
->is_stmt
= reader
->line_header
->default_is_stmt
;
17709 state
->discriminator
= 0;
17712 /* Check address and if invalid nop-out the rest of the lines in this
17716 check_line_address (struct dwarf2_cu
*cu
, lnp_state_machine
*state
,
17717 const gdb_byte
*line_ptr
,
17718 CORE_ADDR lowpc
, CORE_ADDR address
)
17720 /* If address < lowpc then it's not a usable value, it's outside the
17721 pc range of the CU. However, we restrict the test to only address
17722 values of zero to preserve GDB's previous behaviour which is to
17723 handle the specific case of a function being GC'd by the linker. */
17725 if (address
== 0 && address
< lowpc
)
17727 /* This line table is for a function which has been
17728 GCd by the linker. Ignore it. PR gdb/12528 */
17730 struct objfile
*objfile
= cu
->objfile
;
17731 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
17733 complaint (&symfile_complaints
,
17734 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
17735 line_offset
, objfile_name (objfile
));
17736 state
->record_line
= noop_record_line
;
17737 /* Note: sm.record_line is left as noop_record_line
17738 until we see DW_LNE_end_sequence. */
17742 /* Subroutine of dwarf_decode_lines to simplify it.
17743 Process the line number information in LH.
17744 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
17745 program in order to set included_p for every referenced header. */
17748 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
17749 const int decode_for_pst_p
, CORE_ADDR lowpc
)
17751 const gdb_byte
*line_ptr
, *extended_end
;
17752 const gdb_byte
*line_end
;
17753 unsigned int bytes_read
, extended_len
;
17754 unsigned char op_code
, extended_op
;
17755 CORE_ADDR baseaddr
;
17756 struct objfile
*objfile
= cu
->objfile
;
17757 bfd
*abfd
= objfile
->obfd
;
17758 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17759 /* Non-zero if we're recording line info (as opposed to building partial
17761 int record_lines_p
= !decode_for_pst_p
;
17762 /* A collection of things we need to pass to dwarf_record_line. */
17763 lnp_reader_state reader_state
;
17765 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17767 line_ptr
= lh
->statement_program_start
;
17768 line_end
= lh
->statement_program_end
;
17770 reader_state
.gdbarch
= gdbarch
;
17771 reader_state
.line_header
= lh
;
17772 reader_state
.record_lines_p
= record_lines_p
;
17774 /* Read the statement sequences until there's nothing left. */
17775 while (line_ptr
< line_end
)
17777 /* The DWARF line number program state machine. */
17778 lnp_state_machine state_machine
;
17779 int end_sequence
= 0;
17781 /* Reset the state machine at the start of each sequence. */
17782 init_lnp_state_machine (&state_machine
, &reader_state
);
17784 if (record_lines_p
&& lh
->num_file_names
>= state_machine
.file
)
17786 /* Start a subfile for the current file of the state machine. */
17787 /* lh->include_dirs and lh->file_names are 0-based, but the
17788 directory and file name numbers in the statement program
17790 struct file_entry
*fe
= &lh
->file_names
[state_machine
.file
- 1];
17791 const char *dir
= NULL
;
17793 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
17794 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17796 dwarf2_start_subfile (fe
->name
, dir
);
17799 /* Decode the table. */
17800 while (line_ptr
< line_end
&& !end_sequence
)
17802 op_code
= read_1_byte (abfd
, line_ptr
);
17805 if (op_code
>= lh
->opcode_base
)
17807 /* Special opcode. */
17808 unsigned char adj_opcode
;
17809 CORE_ADDR addr_adj
;
17812 adj_opcode
= op_code
- lh
->opcode_base
;
17813 addr_adj
= (((state_machine
.op_index
17814 + (adj_opcode
/ lh
->line_range
))
17815 / lh
->maximum_ops_per_instruction
)
17816 * lh
->minimum_instruction_length
);
17817 state_machine
.address
17818 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17819 state_machine
.op_index
= ((state_machine
.op_index
17820 + (adj_opcode
/ lh
->line_range
))
17821 % lh
->maximum_ops_per_instruction
);
17822 line_delta
= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
17823 state_machine
.line
+= line_delta
;
17824 if (line_delta
!= 0)
17825 state_machine
.line_has_non_zero_discriminator
17826 = state_machine
.discriminator
!= 0;
17828 dwarf_record_line (&reader_state
, &state_machine
, 0);
17829 state_machine
.discriminator
= 0;
17831 else switch (op_code
)
17833 case DW_LNS_extended_op
:
17834 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
17836 line_ptr
+= bytes_read
;
17837 extended_end
= line_ptr
+ extended_len
;
17838 extended_op
= read_1_byte (abfd
, line_ptr
);
17840 switch (extended_op
)
17842 case DW_LNE_end_sequence
:
17843 state_machine
.record_line
= record_line
;
17846 case DW_LNE_set_address
:
17849 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
17851 line_ptr
+= bytes_read
;
17852 check_line_address (cu
, &state_machine
, line_ptr
,
17854 state_machine
.op_index
= 0;
17855 address
+= baseaddr
;
17856 state_machine
.address
17857 = gdbarch_adjust_dwarf2_line (gdbarch
, address
, 0);
17860 case DW_LNE_define_file
:
17862 const char *cur_file
;
17863 unsigned int dir_index
, mod_time
, length
;
17865 cur_file
= read_direct_string (abfd
, line_ptr
,
17867 line_ptr
+= bytes_read
;
17869 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17870 line_ptr
+= bytes_read
;
17872 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17873 line_ptr
+= bytes_read
;
17875 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17876 line_ptr
+= bytes_read
;
17877 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17880 case DW_LNE_set_discriminator
:
17881 /* The discriminator is not interesting to the debugger;
17882 just ignore it. We still need to check its value though:
17883 if there are consecutive entries for the same
17884 (non-prologue) line we want to coalesce them.
17886 state_machine
.discriminator
17887 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17888 state_machine
.line_has_non_zero_discriminator
17889 |= state_machine
.discriminator
!= 0;
17890 line_ptr
+= bytes_read
;
17893 complaint (&symfile_complaints
,
17894 _("mangled .debug_line section"));
17897 /* Make sure that we parsed the extended op correctly. If e.g.
17898 we expected a different address size than the producer used,
17899 we may have read the wrong number of bytes. */
17900 if (line_ptr
!= extended_end
)
17902 complaint (&symfile_complaints
,
17903 _("mangled .debug_line section"));
17908 dwarf_record_line (&reader_state
, &state_machine
, 0);
17909 state_machine
.discriminator
= 0;
17911 case DW_LNS_advance_pc
:
17914 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17915 CORE_ADDR addr_adj
;
17917 addr_adj
= (((state_machine
.op_index
+ adjust
)
17918 / lh
->maximum_ops_per_instruction
)
17919 * lh
->minimum_instruction_length
);
17920 state_machine
.address
17921 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17922 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
17923 % lh
->maximum_ops_per_instruction
);
17924 line_ptr
+= bytes_read
;
17927 case DW_LNS_advance_line
:
17930 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
17932 state_machine
.line
+= line_delta
;
17933 if (line_delta
!= 0)
17934 state_machine
.line_has_non_zero_discriminator
17935 = state_machine
.discriminator
!= 0;
17936 line_ptr
+= bytes_read
;
17939 case DW_LNS_set_file
:
17941 /* The arrays lh->include_dirs and lh->file_names are
17942 0-based, but the directory and file name numbers in
17943 the statement program are 1-based. */
17944 struct file_entry
*fe
;
17945 const char *dir
= NULL
;
17947 state_machine
.file
= read_unsigned_leb128 (abfd
, line_ptr
,
17949 line_ptr
+= bytes_read
;
17950 if (state_machine
.file
== 0
17951 || state_machine
.file
- 1 >= lh
->num_file_names
)
17952 dwarf2_debug_line_missing_file_complaint ();
17955 fe
= &lh
->file_names
[state_machine
.file
- 1];
17956 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
17957 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17958 if (record_lines_p
)
17960 state_machine
.last_subfile
= current_subfile
;
17961 state_machine
.line_has_non_zero_discriminator
17962 = state_machine
.discriminator
!= 0;
17963 dwarf2_start_subfile (fe
->name
, dir
);
17968 case DW_LNS_set_column
:
17969 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17970 line_ptr
+= bytes_read
;
17972 case DW_LNS_negate_stmt
:
17973 state_machine
.is_stmt
= (!state_machine
.is_stmt
);
17975 case DW_LNS_set_basic_block
:
17977 /* Add to the address register of the state machine the
17978 address increment value corresponding to special opcode
17979 255. I.e., this value is scaled by the minimum
17980 instruction length since special opcode 255 would have
17981 scaled the increment. */
17982 case DW_LNS_const_add_pc
:
17984 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
17985 CORE_ADDR addr_adj
;
17987 addr_adj
= (((state_machine
.op_index
+ adjust
)
17988 / lh
->maximum_ops_per_instruction
)
17989 * lh
->minimum_instruction_length
);
17990 state_machine
.address
17991 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17992 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
17993 % lh
->maximum_ops_per_instruction
);
17996 case DW_LNS_fixed_advance_pc
:
17998 CORE_ADDR addr_adj
;
18000 addr_adj
= read_2_bytes (abfd
, line_ptr
);
18001 state_machine
.address
18002 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18003 state_machine
.op_index
= 0;
18009 /* Unknown standard opcode, ignore it. */
18012 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
18014 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18015 line_ptr
+= bytes_read
;
18022 dwarf2_debug_line_missing_end_sequence_complaint ();
18024 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
18025 in which case we still finish recording the last line). */
18026 dwarf_record_line (&reader_state
, &state_machine
, 1);
18030 /* Decode the Line Number Program (LNP) for the given line_header
18031 structure and CU. The actual information extracted and the type
18032 of structures created from the LNP depends on the value of PST.
18034 1. If PST is NULL, then this procedure uses the data from the program
18035 to create all necessary symbol tables, and their linetables.
18037 2. If PST is not NULL, this procedure reads the program to determine
18038 the list of files included by the unit represented by PST, and
18039 builds all the associated partial symbol tables.
18041 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
18042 It is used for relative paths in the line table.
18043 NOTE: When processing partial symtabs (pst != NULL),
18044 comp_dir == pst->dirname.
18046 NOTE: It is important that psymtabs have the same file name (via strcmp)
18047 as the corresponding symtab. Since COMP_DIR is not used in the name of the
18048 symtab we don't use it in the name of the psymtabs we create.
18049 E.g. expand_line_sal requires this when finding psymtabs to expand.
18050 A good testcase for this is mb-inline.exp.
18052 LOWPC is the lowest address in CU (or 0 if not known).
18054 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
18055 for its PC<->lines mapping information. Otherwise only the filename
18056 table is read in. */
18059 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
18060 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
18061 CORE_ADDR lowpc
, int decode_mapping
)
18063 struct objfile
*objfile
= cu
->objfile
;
18064 const int decode_for_pst_p
= (pst
!= NULL
);
18066 if (decode_mapping
)
18067 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
18069 if (decode_for_pst_p
)
18073 /* Now that we're done scanning the Line Header Program, we can
18074 create the psymtab of each included file. */
18075 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
18076 if (lh
->file_names
[file_index
].included_p
== 1)
18078 const char *include_name
=
18079 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
18080 if (include_name
!= NULL
)
18081 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
18086 /* Make sure a symtab is created for every file, even files
18087 which contain only variables (i.e. no code with associated
18089 struct compunit_symtab
*cust
= buildsym_compunit_symtab ();
18092 for (i
= 0; i
< lh
->num_file_names
; i
++)
18094 const char *dir
= NULL
;
18095 struct file_entry
*fe
;
18097 fe
= &lh
->file_names
[i
];
18098 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
18099 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
18100 dwarf2_start_subfile (fe
->name
, dir
);
18102 if (current_subfile
->symtab
== NULL
)
18104 current_subfile
->symtab
18105 = allocate_symtab (cust
, current_subfile
->name
);
18107 fe
->symtab
= current_subfile
->symtab
;
18112 /* Start a subfile for DWARF. FILENAME is the name of the file and
18113 DIRNAME the name of the source directory which contains FILENAME
18114 or NULL if not known.
18115 This routine tries to keep line numbers from identical absolute and
18116 relative file names in a common subfile.
18118 Using the `list' example from the GDB testsuite, which resides in
18119 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
18120 of /srcdir/list0.c yields the following debugging information for list0.c:
18122 DW_AT_name: /srcdir/list0.c
18123 DW_AT_comp_dir: /compdir
18124 files.files[0].name: list0.h
18125 files.files[0].dir: /srcdir
18126 files.files[1].name: list0.c
18127 files.files[1].dir: /srcdir
18129 The line number information for list0.c has to end up in a single
18130 subfile, so that `break /srcdir/list0.c:1' works as expected.
18131 start_subfile will ensure that this happens provided that we pass the
18132 concatenation of files.files[1].dir and files.files[1].name as the
18136 dwarf2_start_subfile (const char *filename
, const char *dirname
)
18140 /* In order not to lose the line information directory,
18141 we concatenate it to the filename when it makes sense.
18142 Note that the Dwarf3 standard says (speaking of filenames in line
18143 information): ``The directory index is ignored for file names
18144 that represent full path names''. Thus ignoring dirname in the
18145 `else' branch below isn't an issue. */
18147 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
18149 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
18153 start_subfile (filename
);
18159 /* Start a symtab for DWARF.
18160 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
18162 static struct compunit_symtab
*
18163 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
18164 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
18166 struct compunit_symtab
*cust
18167 = start_symtab (cu
->objfile
, name
, comp_dir
, low_pc
);
18169 record_debugformat ("DWARF 2");
18170 record_producer (cu
->producer
);
18172 /* We assume that we're processing GCC output. */
18173 processing_gcc_compilation
= 2;
18175 cu
->processing_has_namespace_info
= 0;
18181 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
18182 struct dwarf2_cu
*cu
)
18184 struct objfile
*objfile
= cu
->objfile
;
18185 struct comp_unit_head
*cu_header
= &cu
->header
;
18187 /* NOTE drow/2003-01-30: There used to be a comment and some special
18188 code here to turn a symbol with DW_AT_external and a
18189 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
18190 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
18191 with some versions of binutils) where shared libraries could have
18192 relocations against symbols in their debug information - the
18193 minimal symbol would have the right address, but the debug info
18194 would not. It's no longer necessary, because we will explicitly
18195 apply relocations when we read in the debug information now. */
18197 /* A DW_AT_location attribute with no contents indicates that a
18198 variable has been optimized away. */
18199 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
18201 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18205 /* Handle one degenerate form of location expression specially, to
18206 preserve GDB's previous behavior when section offsets are
18207 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
18208 then mark this symbol as LOC_STATIC. */
18210 if (attr_form_is_block (attr
)
18211 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
18212 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
18213 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
18214 && (DW_BLOCK (attr
)->size
18215 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
18217 unsigned int dummy
;
18219 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
18220 SYMBOL_VALUE_ADDRESS (sym
) =
18221 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
18223 SYMBOL_VALUE_ADDRESS (sym
) =
18224 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
18225 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
18226 fixup_symbol_section (sym
, objfile
);
18227 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
18228 SYMBOL_SECTION (sym
));
18232 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
18233 expression evaluator, and use LOC_COMPUTED only when necessary
18234 (i.e. when the value of a register or memory location is
18235 referenced, or a thread-local block, etc.). Then again, it might
18236 not be worthwhile. I'm assuming that it isn't unless performance
18237 or memory numbers show me otherwise. */
18239 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
18241 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
18242 cu
->has_loclist
= 1;
18245 /* Given a pointer to a DWARF information entry, figure out if we need
18246 to make a symbol table entry for it, and if so, create a new entry
18247 and return a pointer to it.
18248 If TYPE is NULL, determine symbol type from the die, otherwise
18249 used the passed type.
18250 If SPACE is not NULL, use it to hold the new symbol. If it is
18251 NULL, allocate a new symbol on the objfile's obstack. */
18253 static struct symbol
*
18254 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
18255 struct symbol
*space
)
18257 struct objfile
*objfile
= cu
->objfile
;
18258 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18259 struct symbol
*sym
= NULL
;
18261 struct attribute
*attr
= NULL
;
18262 struct attribute
*attr2
= NULL
;
18263 CORE_ADDR baseaddr
;
18264 struct pending
**list_to_add
= NULL
;
18266 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
18268 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
18270 name
= dwarf2_name (die
, cu
);
18273 const char *linkagename
;
18274 int suppress_add
= 0;
18279 sym
= allocate_symbol (objfile
);
18280 OBJSTAT (objfile
, n_syms
++);
18282 /* Cache this symbol's name and the name's demangled form (if any). */
18283 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
18284 linkagename
= dwarf2_physname (name
, die
, cu
);
18285 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
18287 /* Fortran does not have mangling standard and the mangling does differ
18288 between gfortran, iFort etc. */
18289 if (cu
->language
== language_fortran
18290 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
18291 symbol_set_demangled_name (&(sym
->ginfo
),
18292 dwarf2_full_name (name
, die
, cu
),
18295 /* Default assumptions.
18296 Use the passed type or decode it from the die. */
18297 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18298 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18300 SYMBOL_TYPE (sym
) = type
;
18302 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
18303 attr
= dwarf2_attr (die
,
18304 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
18308 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
18311 attr
= dwarf2_attr (die
,
18312 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
18316 int file_index
= DW_UNSND (attr
);
18318 if (cu
->line_header
== NULL
18319 || file_index
> cu
->line_header
->num_file_names
)
18320 complaint (&symfile_complaints
,
18321 _("file index out of range"));
18322 else if (file_index
> 0)
18324 struct file_entry
*fe
;
18326 fe
= &cu
->line_header
->file_names
[file_index
- 1];
18327 symbol_set_symtab (sym
, fe
->symtab
);
18334 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
18339 addr
= attr_value_as_address (attr
);
18340 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
18341 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
18343 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
18344 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
18345 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
18346 add_symbol_to_list (sym
, cu
->list_in_scope
);
18348 case DW_TAG_subprogram
:
18349 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18351 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18352 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18353 if ((attr2
&& (DW_UNSND (attr2
) != 0))
18354 || cu
->language
== language_ada
)
18356 /* Subprograms marked external are stored as a global symbol.
18357 Ada subprograms, whether marked external or not, are always
18358 stored as a global symbol, because we want to be able to
18359 access them globally. For instance, we want to be able
18360 to break on a nested subprogram without having to
18361 specify the context. */
18362 list_to_add
= &global_symbols
;
18366 list_to_add
= cu
->list_in_scope
;
18369 case DW_TAG_inlined_subroutine
:
18370 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18372 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18373 SYMBOL_INLINED (sym
) = 1;
18374 list_to_add
= cu
->list_in_scope
;
18376 case DW_TAG_template_value_param
:
18378 /* Fall through. */
18379 case DW_TAG_constant
:
18380 case DW_TAG_variable
:
18381 case DW_TAG_member
:
18382 /* Compilation with minimal debug info may result in
18383 variables with missing type entries. Change the
18384 misleading `void' type to something sensible. */
18385 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
18387 = objfile_type (objfile
)->nodebug_data_symbol
;
18389 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18390 /* In the case of DW_TAG_member, we should only be called for
18391 static const members. */
18392 if (die
->tag
== DW_TAG_member
)
18394 /* dwarf2_add_field uses die_is_declaration,
18395 so we do the same. */
18396 gdb_assert (die_is_declaration (die
, cu
));
18401 dwarf2_const_value (attr
, sym
, cu
);
18402 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18405 if (attr2
&& (DW_UNSND (attr2
) != 0))
18406 list_to_add
= &global_symbols
;
18408 list_to_add
= cu
->list_in_scope
;
18412 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18415 var_decode_location (attr
, sym
, cu
);
18416 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18418 /* Fortran explicitly imports any global symbols to the local
18419 scope by DW_TAG_common_block. */
18420 if (cu
->language
== language_fortran
&& die
->parent
18421 && die
->parent
->tag
== DW_TAG_common_block
)
18424 if (SYMBOL_CLASS (sym
) == LOC_STATIC
18425 && SYMBOL_VALUE_ADDRESS (sym
) == 0
18426 && !dwarf2_per_objfile
->has_section_at_zero
)
18428 /* When a static variable is eliminated by the linker,
18429 the corresponding debug information is not stripped
18430 out, but the variable address is set to null;
18431 do not add such variables into symbol table. */
18433 else if (attr2
&& (DW_UNSND (attr2
) != 0))
18435 /* Workaround gfortran PR debug/40040 - it uses
18436 DW_AT_location for variables in -fPIC libraries which may
18437 get overriden by other libraries/executable and get
18438 a different address. Resolve it by the minimal symbol
18439 which may come from inferior's executable using copy
18440 relocation. Make this workaround only for gfortran as for
18441 other compilers GDB cannot guess the minimal symbol
18442 Fortran mangling kind. */
18443 if (cu
->language
== language_fortran
&& die
->parent
18444 && die
->parent
->tag
== DW_TAG_module
18446 && startswith (cu
->producer
, "GNU Fortran "))
18447 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18449 /* A variable with DW_AT_external is never static,
18450 but it may be block-scoped. */
18451 list_to_add
= (cu
->list_in_scope
== &file_symbols
18452 ? &global_symbols
: cu
->list_in_scope
);
18455 list_to_add
= cu
->list_in_scope
;
18459 /* We do not know the address of this symbol.
18460 If it is an external symbol and we have type information
18461 for it, enter the symbol as a LOC_UNRESOLVED symbol.
18462 The address of the variable will then be determined from
18463 the minimal symbol table whenever the variable is
18465 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18467 /* Fortran explicitly imports any global symbols to the local
18468 scope by DW_TAG_common_block. */
18469 if (cu
->language
== language_fortran
&& die
->parent
18470 && die
->parent
->tag
== DW_TAG_common_block
)
18472 /* SYMBOL_CLASS doesn't matter here because
18473 read_common_block is going to reset it. */
18475 list_to_add
= cu
->list_in_scope
;
18477 else if (attr2
&& (DW_UNSND (attr2
) != 0)
18478 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
18480 /* A variable with DW_AT_external is never static, but it
18481 may be block-scoped. */
18482 list_to_add
= (cu
->list_in_scope
== &file_symbols
18483 ? &global_symbols
: cu
->list_in_scope
);
18485 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18487 else if (!die_is_declaration (die
, cu
))
18489 /* Use the default LOC_OPTIMIZED_OUT class. */
18490 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
18492 list_to_add
= cu
->list_in_scope
;
18496 case DW_TAG_formal_parameter
:
18497 /* If we are inside a function, mark this as an argument. If
18498 not, we might be looking at an argument to an inlined function
18499 when we do not have enough information to show inlined frames;
18500 pretend it's a local variable in that case so that the user can
18502 if (context_stack_depth
> 0
18503 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
18504 SYMBOL_IS_ARGUMENT (sym
) = 1;
18505 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18508 var_decode_location (attr
, sym
, cu
);
18510 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18513 dwarf2_const_value (attr
, sym
, cu
);
18516 list_to_add
= cu
->list_in_scope
;
18518 case DW_TAG_unspecified_parameters
:
18519 /* From varargs functions; gdb doesn't seem to have any
18520 interest in this information, so just ignore it for now.
18523 case DW_TAG_template_type_param
:
18525 /* Fall through. */
18526 case DW_TAG_class_type
:
18527 case DW_TAG_interface_type
:
18528 case DW_TAG_structure_type
:
18529 case DW_TAG_union_type
:
18530 case DW_TAG_set_type
:
18531 case DW_TAG_enumeration_type
:
18532 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18533 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
18536 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
18537 really ever be static objects: otherwise, if you try
18538 to, say, break of a class's method and you're in a file
18539 which doesn't mention that class, it won't work unless
18540 the check for all static symbols in lookup_symbol_aux
18541 saves you. See the OtherFileClass tests in
18542 gdb.c++/namespace.exp. */
18546 list_to_add
= (cu
->list_in_scope
== &file_symbols
18547 && (cu
->language
== language_cplus
18548 || cu
->language
== language_java
)
18549 ? &global_symbols
: cu
->list_in_scope
);
18551 /* The semantics of C++ state that "struct foo {
18552 ... }" also defines a typedef for "foo". A Java
18553 class declaration also defines a typedef for the
18555 if (cu
->language
== language_cplus
18556 || cu
->language
== language_java
18557 || cu
->language
== language_ada
)
18559 /* The symbol's name is already allocated along
18560 with this objfile, so we don't need to
18561 duplicate it for the type. */
18562 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
18563 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
18568 case DW_TAG_typedef
:
18569 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18570 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18571 list_to_add
= cu
->list_in_scope
;
18573 case DW_TAG_base_type
:
18574 case DW_TAG_subrange_type
:
18575 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18576 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18577 list_to_add
= cu
->list_in_scope
;
18579 case DW_TAG_enumerator
:
18580 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18583 dwarf2_const_value (attr
, sym
, cu
);
18586 /* NOTE: carlton/2003-11-10: See comment above in the
18587 DW_TAG_class_type, etc. block. */
18589 list_to_add
= (cu
->list_in_scope
== &file_symbols
18590 && (cu
->language
== language_cplus
18591 || cu
->language
== language_java
)
18592 ? &global_symbols
: cu
->list_in_scope
);
18595 case DW_TAG_imported_declaration
:
18596 case DW_TAG_namespace
:
18597 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18598 list_to_add
= &global_symbols
;
18600 case DW_TAG_module
:
18601 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18602 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
18603 list_to_add
= &global_symbols
;
18605 case DW_TAG_common_block
:
18606 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
18607 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
18608 add_symbol_to_list (sym
, cu
->list_in_scope
);
18611 /* Not a tag we recognize. Hopefully we aren't processing
18612 trash data, but since we must specifically ignore things
18613 we don't recognize, there is nothing else we should do at
18615 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
18616 dwarf_tag_name (die
->tag
));
18622 sym
->hash_next
= objfile
->template_symbols
;
18623 objfile
->template_symbols
= sym
;
18624 list_to_add
= NULL
;
18627 if (list_to_add
!= NULL
)
18628 add_symbol_to_list (sym
, list_to_add
);
18630 /* For the benefit of old versions of GCC, check for anonymous
18631 namespaces based on the demangled name. */
18632 if (!cu
->processing_has_namespace_info
18633 && cu
->language
== language_cplus
)
18634 cp_scan_for_anonymous_namespaces (sym
, objfile
);
18639 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18641 static struct symbol
*
18642 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
18644 return new_symbol_full (die
, type
, cu
, NULL
);
18647 /* Given an attr with a DW_FORM_dataN value in host byte order,
18648 zero-extend it as appropriate for the symbol's type. The DWARF
18649 standard (v4) is not entirely clear about the meaning of using
18650 DW_FORM_dataN for a constant with a signed type, where the type is
18651 wider than the data. The conclusion of a discussion on the DWARF
18652 list was that this is unspecified. We choose to always zero-extend
18653 because that is the interpretation long in use by GCC. */
18656 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
18657 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
18659 struct objfile
*objfile
= cu
->objfile
;
18660 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
18661 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
18662 LONGEST l
= DW_UNSND (attr
);
18664 if (bits
< sizeof (*value
) * 8)
18666 l
&= ((LONGEST
) 1 << bits
) - 1;
18669 else if (bits
== sizeof (*value
) * 8)
18673 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
18674 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
18681 /* Read a constant value from an attribute. Either set *VALUE, or if
18682 the value does not fit in *VALUE, set *BYTES - either already
18683 allocated on the objfile obstack, or newly allocated on OBSTACK,
18684 or, set *BATON, if we translated the constant to a location
18688 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
18689 const char *name
, struct obstack
*obstack
,
18690 struct dwarf2_cu
*cu
,
18691 LONGEST
*value
, const gdb_byte
**bytes
,
18692 struct dwarf2_locexpr_baton
**baton
)
18694 struct objfile
*objfile
= cu
->objfile
;
18695 struct comp_unit_head
*cu_header
= &cu
->header
;
18696 struct dwarf_block
*blk
;
18697 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
18698 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
18704 switch (attr
->form
)
18707 case DW_FORM_GNU_addr_index
:
18711 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
18712 dwarf2_const_value_length_mismatch_complaint (name
,
18713 cu_header
->addr_size
,
18714 TYPE_LENGTH (type
));
18715 /* Symbols of this form are reasonably rare, so we just
18716 piggyback on the existing location code rather than writing
18717 a new implementation of symbol_computed_ops. */
18718 *baton
= obstack_alloc (obstack
, sizeof (struct dwarf2_locexpr_baton
));
18719 (*baton
)->per_cu
= cu
->per_cu
;
18720 gdb_assert ((*baton
)->per_cu
);
18722 (*baton
)->size
= 2 + cu_header
->addr_size
;
18723 data
= obstack_alloc (obstack
, (*baton
)->size
);
18724 (*baton
)->data
= data
;
18726 data
[0] = DW_OP_addr
;
18727 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
18728 byte_order
, DW_ADDR (attr
));
18729 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
18732 case DW_FORM_string
:
18734 case DW_FORM_GNU_str_index
:
18735 case DW_FORM_GNU_strp_alt
:
18736 /* DW_STRING is already allocated on the objfile obstack, point
18738 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
18740 case DW_FORM_block1
:
18741 case DW_FORM_block2
:
18742 case DW_FORM_block4
:
18743 case DW_FORM_block
:
18744 case DW_FORM_exprloc
:
18745 blk
= DW_BLOCK (attr
);
18746 if (TYPE_LENGTH (type
) != blk
->size
)
18747 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
18748 TYPE_LENGTH (type
));
18749 *bytes
= blk
->data
;
18752 /* The DW_AT_const_value attributes are supposed to carry the
18753 symbol's value "represented as it would be on the target
18754 architecture." By the time we get here, it's already been
18755 converted to host endianness, so we just need to sign- or
18756 zero-extend it as appropriate. */
18757 case DW_FORM_data1
:
18758 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
18760 case DW_FORM_data2
:
18761 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
18763 case DW_FORM_data4
:
18764 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
18766 case DW_FORM_data8
:
18767 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
18770 case DW_FORM_sdata
:
18771 *value
= DW_SND (attr
);
18774 case DW_FORM_udata
:
18775 *value
= DW_UNSND (attr
);
18779 complaint (&symfile_complaints
,
18780 _("unsupported const value attribute form: '%s'"),
18781 dwarf_form_name (attr
->form
));
18788 /* Copy constant value from an attribute to a symbol. */
18791 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
18792 struct dwarf2_cu
*cu
)
18794 struct objfile
*objfile
= cu
->objfile
;
18795 struct comp_unit_head
*cu_header
= &cu
->header
;
18797 const gdb_byte
*bytes
;
18798 struct dwarf2_locexpr_baton
*baton
;
18800 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
18801 SYMBOL_PRINT_NAME (sym
),
18802 &objfile
->objfile_obstack
, cu
,
18803 &value
, &bytes
, &baton
);
18807 SYMBOL_LOCATION_BATON (sym
) = baton
;
18808 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
18810 else if (bytes
!= NULL
)
18812 SYMBOL_VALUE_BYTES (sym
) = bytes
;
18813 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
18817 SYMBOL_VALUE (sym
) = value
;
18818 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
18822 /* Return the type of the die in question using its DW_AT_type attribute. */
18824 static struct type
*
18825 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18827 struct attribute
*type_attr
;
18829 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
18832 /* A missing DW_AT_type represents a void type. */
18833 return objfile_type (cu
->objfile
)->builtin_void
;
18836 return lookup_die_type (die
, type_attr
, cu
);
18839 /* True iff CU's producer generates GNAT Ada auxiliary information
18840 that allows to find parallel types through that information instead
18841 of having to do expensive parallel lookups by type name. */
18844 need_gnat_info (struct dwarf2_cu
*cu
)
18846 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18847 of GNAT produces this auxiliary information, without any indication
18848 that it is produced. Part of enhancing the FSF version of GNAT
18849 to produce that information will be to put in place an indicator
18850 that we can use in order to determine whether the descriptive type
18851 info is available or not. One suggestion that has been made is
18852 to use a new attribute, attached to the CU die. For now, assume
18853 that the descriptive type info is not available. */
18857 /* Return the auxiliary type of the die in question using its
18858 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18859 attribute is not present. */
18861 static struct type
*
18862 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18864 struct attribute
*type_attr
;
18866 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
18870 return lookup_die_type (die
, type_attr
, cu
);
18873 /* If DIE has a descriptive_type attribute, then set the TYPE's
18874 descriptive type accordingly. */
18877 set_descriptive_type (struct type
*type
, struct die_info
*die
,
18878 struct dwarf2_cu
*cu
)
18880 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
18882 if (descriptive_type
)
18884 ALLOCATE_GNAT_AUX_TYPE (type
);
18885 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
18889 /* Return the containing type of the die in question using its
18890 DW_AT_containing_type attribute. */
18892 static struct type
*
18893 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18895 struct attribute
*type_attr
;
18897 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
18899 error (_("Dwarf Error: Problem turning containing type into gdb type "
18900 "[in module %s]"), objfile_name (cu
->objfile
));
18902 return lookup_die_type (die
, type_attr
, cu
);
18905 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18907 static struct type
*
18908 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
18910 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18911 char *message
, *saved
;
18913 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18914 objfile_name (objfile
),
18915 cu
->header
.offset
.sect_off
,
18916 die
->offset
.sect_off
);
18917 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
18918 message
, strlen (message
));
18921 return init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
18924 /* Look up the type of DIE in CU using its type attribute ATTR.
18925 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18926 DW_AT_containing_type.
18927 If there is no type substitute an error marker. */
18929 static struct type
*
18930 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
18931 struct dwarf2_cu
*cu
)
18933 struct objfile
*objfile
= cu
->objfile
;
18934 struct type
*this_type
;
18936 gdb_assert (attr
->name
== DW_AT_type
18937 || attr
->name
== DW_AT_GNAT_descriptive_type
18938 || attr
->name
== DW_AT_containing_type
);
18940 /* First see if we have it cached. */
18942 if (attr
->form
== DW_FORM_GNU_ref_alt
)
18944 struct dwarf2_per_cu_data
*per_cu
;
18945 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18947 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
18948 this_type
= get_die_type_at_offset (offset
, per_cu
);
18950 else if (attr_form_is_ref (attr
))
18952 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18954 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
18956 else if (attr
->form
== DW_FORM_ref_sig8
)
18958 ULONGEST signature
= DW_SIGNATURE (attr
);
18960 return get_signatured_type (die
, signature
, cu
);
18964 complaint (&symfile_complaints
,
18965 _("Dwarf Error: Bad type attribute %s in DIE"
18966 " at 0x%x [in module %s]"),
18967 dwarf_attr_name (attr
->name
), die
->offset
.sect_off
,
18968 objfile_name (objfile
));
18969 return build_error_marker_type (cu
, die
);
18972 /* If not cached we need to read it in. */
18974 if (this_type
== NULL
)
18976 struct die_info
*type_die
= NULL
;
18977 struct dwarf2_cu
*type_cu
= cu
;
18979 if (attr_form_is_ref (attr
))
18980 type_die
= follow_die_ref (die
, attr
, &type_cu
);
18981 if (type_die
== NULL
)
18982 return build_error_marker_type (cu
, die
);
18983 /* If we find the type now, it's probably because the type came
18984 from an inter-CU reference and the type's CU got expanded before
18986 this_type
= read_type_die (type_die
, type_cu
);
18989 /* If we still don't have a type use an error marker. */
18991 if (this_type
== NULL
)
18992 return build_error_marker_type (cu
, die
);
18997 /* Return the type in DIE, CU.
18998 Returns NULL for invalid types.
19000 This first does a lookup in die_type_hash,
19001 and only reads the die in if necessary.
19003 NOTE: This can be called when reading in partial or full symbols. */
19005 static struct type
*
19006 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
19008 struct type
*this_type
;
19010 this_type
= get_die_type (die
, cu
);
19014 return read_type_die_1 (die
, cu
);
19017 /* Read the type in DIE, CU.
19018 Returns NULL for invalid types. */
19020 static struct type
*
19021 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
19023 struct type
*this_type
= NULL
;
19027 case DW_TAG_class_type
:
19028 case DW_TAG_interface_type
:
19029 case DW_TAG_structure_type
:
19030 case DW_TAG_union_type
:
19031 this_type
= read_structure_type (die
, cu
);
19033 case DW_TAG_enumeration_type
:
19034 this_type
= read_enumeration_type (die
, cu
);
19036 case DW_TAG_subprogram
:
19037 case DW_TAG_subroutine_type
:
19038 case DW_TAG_inlined_subroutine
:
19039 this_type
= read_subroutine_type (die
, cu
);
19041 case DW_TAG_array_type
:
19042 this_type
= read_array_type (die
, cu
);
19044 case DW_TAG_set_type
:
19045 this_type
= read_set_type (die
, cu
);
19047 case DW_TAG_pointer_type
:
19048 this_type
= read_tag_pointer_type (die
, cu
);
19050 case DW_TAG_ptr_to_member_type
:
19051 this_type
= read_tag_ptr_to_member_type (die
, cu
);
19053 case DW_TAG_reference_type
:
19054 this_type
= read_tag_reference_type (die
, cu
);
19056 case DW_TAG_const_type
:
19057 this_type
= read_tag_const_type (die
, cu
);
19059 case DW_TAG_volatile_type
:
19060 this_type
= read_tag_volatile_type (die
, cu
);
19062 case DW_TAG_restrict_type
:
19063 this_type
= read_tag_restrict_type (die
, cu
);
19065 case DW_TAG_string_type
:
19066 this_type
= read_tag_string_type (die
, cu
);
19068 case DW_TAG_typedef
:
19069 this_type
= read_typedef (die
, cu
);
19071 case DW_TAG_subrange_type
:
19072 this_type
= read_subrange_type (die
, cu
);
19074 case DW_TAG_base_type
:
19075 this_type
= read_base_type (die
, cu
);
19077 case DW_TAG_unspecified_type
:
19078 this_type
= read_unspecified_type (die
, cu
);
19080 case DW_TAG_namespace
:
19081 this_type
= read_namespace_type (die
, cu
);
19083 case DW_TAG_module
:
19084 this_type
= read_module_type (die
, cu
);
19086 case DW_TAG_atomic_type
:
19087 this_type
= read_tag_atomic_type (die
, cu
);
19090 complaint (&symfile_complaints
,
19091 _("unexpected tag in read_type_die: '%s'"),
19092 dwarf_tag_name (die
->tag
));
19099 /* See if we can figure out if the class lives in a namespace. We do
19100 this by looking for a member function; its demangled name will
19101 contain namespace info, if there is any.
19102 Return the computed name or NULL.
19103 Space for the result is allocated on the objfile's obstack.
19104 This is the full-die version of guess_partial_die_structure_name.
19105 In this case we know DIE has no useful parent. */
19108 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19110 struct die_info
*spec_die
;
19111 struct dwarf2_cu
*spec_cu
;
19112 struct die_info
*child
;
19115 spec_die
= die_specification (die
, &spec_cu
);
19116 if (spec_die
!= NULL
)
19122 for (child
= die
->child
;
19124 child
= child
->sibling
)
19126 if (child
->tag
== DW_TAG_subprogram
)
19128 struct attribute
*attr
;
19130 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
19132 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
19136 = language_class_name_from_physname (cu
->language_defn
,
19140 if (actual_name
!= NULL
)
19142 const char *die_name
= dwarf2_name (die
, cu
);
19144 if (die_name
!= NULL
19145 && strcmp (die_name
, actual_name
) != 0)
19147 /* Strip off the class name from the full name.
19148 We want the prefix. */
19149 int die_name_len
= strlen (die_name
);
19150 int actual_name_len
= strlen (actual_name
);
19152 /* Test for '::' as a sanity check. */
19153 if (actual_name_len
> die_name_len
+ 2
19154 && actual_name
[actual_name_len
19155 - die_name_len
- 1] == ':')
19157 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19159 actual_name_len
- die_name_len
- 2);
19162 xfree (actual_name
);
19171 /* GCC might emit a nameless typedef that has a linkage name. Determine the
19172 prefix part in such case. See
19173 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19176 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19178 struct attribute
*attr
;
19181 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
19182 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
19185 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19186 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19189 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19191 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19192 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19195 /* dwarf2_name had to be already called. */
19196 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
19198 /* Strip the base name, keep any leading namespaces/classes. */
19199 base
= strrchr (DW_STRING (attr
), ':');
19200 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
19203 return obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19204 DW_STRING (attr
), &base
[-1] - DW_STRING (attr
));
19207 /* Return the name of the namespace/class that DIE is defined within,
19208 or "" if we can't tell. The caller should not xfree the result.
19210 For example, if we're within the method foo() in the following
19220 then determine_prefix on foo's die will return "N::C". */
19222 static const char *
19223 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19225 struct die_info
*parent
, *spec_die
;
19226 struct dwarf2_cu
*spec_cu
;
19227 struct type
*parent_type
;
19230 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
19231 && cu
->language
!= language_fortran
)
19234 retval
= anonymous_struct_prefix (die
, cu
);
19238 /* We have to be careful in the presence of DW_AT_specification.
19239 For example, with GCC 3.4, given the code
19243 // Definition of N::foo.
19247 then we'll have a tree of DIEs like this:
19249 1: DW_TAG_compile_unit
19250 2: DW_TAG_namespace // N
19251 3: DW_TAG_subprogram // declaration of N::foo
19252 4: DW_TAG_subprogram // definition of N::foo
19253 DW_AT_specification // refers to die #3
19255 Thus, when processing die #4, we have to pretend that we're in
19256 the context of its DW_AT_specification, namely the contex of die
19259 spec_die
= die_specification (die
, &spec_cu
);
19260 if (spec_die
== NULL
)
19261 parent
= die
->parent
;
19264 parent
= spec_die
->parent
;
19268 if (parent
== NULL
)
19270 else if (parent
->building_fullname
)
19273 const char *parent_name
;
19275 /* It has been seen on RealView 2.2 built binaries,
19276 DW_TAG_template_type_param types actually _defined_ as
19277 children of the parent class:
19280 template class <class Enum> Class{};
19281 Class<enum E> class_e;
19283 1: DW_TAG_class_type (Class)
19284 2: DW_TAG_enumeration_type (E)
19285 3: DW_TAG_enumerator (enum1:0)
19286 3: DW_TAG_enumerator (enum2:1)
19288 2: DW_TAG_template_type_param
19289 DW_AT_type DW_FORM_ref_udata (E)
19291 Besides being broken debug info, it can put GDB into an
19292 infinite loop. Consider:
19294 When we're building the full name for Class<E>, we'll start
19295 at Class, and go look over its template type parameters,
19296 finding E. We'll then try to build the full name of E, and
19297 reach here. We're now trying to build the full name of E,
19298 and look over the parent DIE for containing scope. In the
19299 broken case, if we followed the parent DIE of E, we'd again
19300 find Class, and once again go look at its template type
19301 arguments, etc., etc. Simply don't consider such parent die
19302 as source-level parent of this die (it can't be, the language
19303 doesn't allow it), and break the loop here. */
19304 name
= dwarf2_name (die
, cu
);
19305 parent_name
= dwarf2_name (parent
, cu
);
19306 complaint (&symfile_complaints
,
19307 _("template param type '%s' defined within parent '%s'"),
19308 name
? name
: "<unknown>",
19309 parent_name
? parent_name
: "<unknown>");
19313 switch (parent
->tag
)
19315 case DW_TAG_namespace
:
19316 parent_type
= read_type_die (parent
, cu
);
19317 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
19318 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
19319 Work around this problem here. */
19320 if (cu
->language
== language_cplus
19321 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
19323 /* We give a name to even anonymous namespaces. */
19324 return TYPE_TAG_NAME (parent_type
);
19325 case DW_TAG_class_type
:
19326 case DW_TAG_interface_type
:
19327 case DW_TAG_structure_type
:
19328 case DW_TAG_union_type
:
19329 case DW_TAG_module
:
19330 parent_type
= read_type_die (parent
, cu
);
19331 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19332 return TYPE_TAG_NAME (parent_type
);
19334 /* An anonymous structure is only allowed non-static data
19335 members; no typedefs, no member functions, et cetera.
19336 So it does not need a prefix. */
19338 case DW_TAG_compile_unit
:
19339 case DW_TAG_partial_unit
:
19340 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
19341 if (cu
->language
== language_cplus
19342 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
19343 && die
->child
!= NULL
19344 && (die
->tag
== DW_TAG_class_type
19345 || die
->tag
== DW_TAG_structure_type
19346 || die
->tag
== DW_TAG_union_type
))
19348 char *name
= guess_full_die_structure_name (die
, cu
);
19353 case DW_TAG_enumeration_type
:
19354 parent_type
= read_type_die (parent
, cu
);
19355 if (TYPE_DECLARED_CLASS (parent_type
))
19357 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19358 return TYPE_TAG_NAME (parent_type
);
19361 /* Fall through. */
19363 return determine_prefix (parent
, cu
);
19367 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
19368 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
19369 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
19370 an obconcat, otherwise allocate storage for the result. The CU argument is
19371 used to determine the language and hence, the appropriate separator. */
19373 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
19376 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
19377 int physname
, struct dwarf2_cu
*cu
)
19379 const char *lead
= "";
19382 if (suffix
== NULL
|| suffix
[0] == '\0'
19383 || prefix
== NULL
|| prefix
[0] == '\0')
19385 else if (cu
->language
== language_java
)
19387 else if (cu
->language
== language_fortran
&& physname
)
19389 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
19390 DW_AT_MIPS_linkage_name is preferred and used instead. */
19398 if (prefix
== NULL
)
19400 if (suffix
== NULL
)
19406 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
19408 strcpy (retval
, lead
);
19409 strcat (retval
, prefix
);
19410 strcat (retval
, sep
);
19411 strcat (retval
, suffix
);
19416 /* We have an obstack. */
19417 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
19421 /* Return sibling of die, NULL if no sibling. */
19423 static struct die_info
*
19424 sibling_die (struct die_info
*die
)
19426 return die
->sibling
;
19429 /* Get name of a die, return NULL if not found. */
19431 static const char *
19432 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
19433 struct obstack
*obstack
)
19435 if (name
&& cu
->language
== language_cplus
)
19437 char *canon_name
= cp_canonicalize_string (name
);
19439 if (canon_name
!= NULL
)
19441 if (strcmp (canon_name
, name
) != 0)
19442 name
= obstack_copy0 (obstack
, canon_name
, strlen (canon_name
));
19443 xfree (canon_name
);
19450 /* Get name of a die, return NULL if not found.
19451 Anonymous namespaces are converted to their magic string. */
19453 static const char *
19454 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19456 struct attribute
*attr
;
19458 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19459 if ((!attr
|| !DW_STRING (attr
))
19460 && die
->tag
!= DW_TAG_namespace
19461 && die
->tag
!= DW_TAG_class_type
19462 && die
->tag
!= DW_TAG_interface_type
19463 && die
->tag
!= DW_TAG_structure_type
19464 && die
->tag
!= DW_TAG_union_type
)
19469 case DW_TAG_compile_unit
:
19470 case DW_TAG_partial_unit
:
19471 /* Compilation units have a DW_AT_name that is a filename, not
19472 a source language identifier. */
19473 case DW_TAG_enumeration_type
:
19474 case DW_TAG_enumerator
:
19475 /* These tags always have simple identifiers already; no need
19476 to canonicalize them. */
19477 return DW_STRING (attr
);
19479 case DW_TAG_namespace
:
19480 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19481 return DW_STRING (attr
);
19482 return CP_ANONYMOUS_NAMESPACE_STR
;
19484 case DW_TAG_subprogram
:
19485 /* Java constructors will all be named "<init>", so return
19486 the class name when we see this special case. */
19487 if (cu
->language
== language_java
19488 && DW_STRING (attr
) != NULL
19489 && strcmp (DW_STRING (attr
), "<init>") == 0)
19491 struct dwarf2_cu
*spec_cu
= cu
;
19492 struct die_info
*spec_die
;
19494 /* GCJ will output '<init>' for Java constructor names.
19495 For this special case, return the name of the parent class. */
19497 /* GCJ may output subprogram DIEs with AT_specification set.
19498 If so, use the name of the specified DIE. */
19499 spec_die
= die_specification (die
, &spec_cu
);
19500 if (spec_die
!= NULL
)
19501 return dwarf2_name (spec_die
, spec_cu
);
19506 if (die
->tag
== DW_TAG_class_type
)
19507 return dwarf2_name (die
, cu
);
19509 while (die
->tag
!= DW_TAG_compile_unit
19510 && die
->tag
!= DW_TAG_partial_unit
);
19514 case DW_TAG_class_type
:
19515 case DW_TAG_interface_type
:
19516 case DW_TAG_structure_type
:
19517 case DW_TAG_union_type
:
19518 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19519 structures or unions. These were of the form "._%d" in GCC 4.1,
19520 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19521 and GCC 4.4. We work around this problem by ignoring these. */
19522 if (attr
&& DW_STRING (attr
)
19523 && (startswith (DW_STRING (attr
), "._")
19524 || startswith (DW_STRING (attr
), "<anonymous")))
19527 /* GCC might emit a nameless typedef that has a linkage name. See
19528 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19529 if (!attr
|| DW_STRING (attr
) == NULL
)
19531 char *demangled
= NULL
;
19533 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19535 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19537 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19540 /* Avoid demangling DW_STRING (attr) the second time on a second
19541 call for the same DIE. */
19542 if (!DW_STRING_IS_CANONICAL (attr
))
19543 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
19549 /* FIXME: we already did this for the partial symbol... */
19551 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19552 demangled
, strlen (demangled
));
19553 DW_STRING_IS_CANONICAL (attr
) = 1;
19556 /* Strip any leading namespaces/classes, keep only the base name.
19557 DW_AT_name for named DIEs does not contain the prefixes. */
19558 base
= strrchr (DW_STRING (attr
), ':');
19559 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
19562 return DW_STRING (attr
);
19571 if (!DW_STRING_IS_CANONICAL (attr
))
19574 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
19575 &cu
->objfile
->per_bfd
->storage_obstack
);
19576 DW_STRING_IS_CANONICAL (attr
) = 1;
19578 return DW_STRING (attr
);
19581 /* Return the die that this die in an extension of, or NULL if there
19582 is none. *EXT_CU is the CU containing DIE on input, and the CU
19583 containing the return value on output. */
19585 static struct die_info
*
19586 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
19588 struct attribute
*attr
;
19590 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
19594 return follow_die_ref (die
, attr
, ext_cu
);
19597 /* Convert a DIE tag into its string name. */
19599 static const char *
19600 dwarf_tag_name (unsigned tag
)
19602 const char *name
= get_DW_TAG_name (tag
);
19605 return "DW_TAG_<unknown>";
19610 /* Convert a DWARF attribute code into its string name. */
19612 static const char *
19613 dwarf_attr_name (unsigned attr
)
19617 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19618 if (attr
== DW_AT_MIPS_fde
)
19619 return "DW_AT_MIPS_fde";
19621 if (attr
== DW_AT_HP_block_index
)
19622 return "DW_AT_HP_block_index";
19625 name
= get_DW_AT_name (attr
);
19628 return "DW_AT_<unknown>";
19633 /* Convert a DWARF value form code into its string name. */
19635 static const char *
19636 dwarf_form_name (unsigned form
)
19638 const char *name
= get_DW_FORM_name (form
);
19641 return "DW_FORM_<unknown>";
19647 dwarf_bool_name (unsigned mybool
)
19655 /* Convert a DWARF type code into its string name. */
19657 static const char *
19658 dwarf_type_encoding_name (unsigned enc
)
19660 const char *name
= get_DW_ATE_name (enc
);
19663 return "DW_ATE_<unknown>";
19669 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
19673 print_spaces (indent
, f
);
19674 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
19675 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
19677 if (die
->parent
!= NULL
)
19679 print_spaces (indent
, f
);
19680 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
19681 die
->parent
->offset
.sect_off
);
19684 print_spaces (indent
, f
);
19685 fprintf_unfiltered (f
, " has children: %s\n",
19686 dwarf_bool_name (die
->child
!= NULL
));
19688 print_spaces (indent
, f
);
19689 fprintf_unfiltered (f
, " attributes:\n");
19691 for (i
= 0; i
< die
->num_attrs
; ++i
)
19693 print_spaces (indent
, f
);
19694 fprintf_unfiltered (f
, " %s (%s) ",
19695 dwarf_attr_name (die
->attrs
[i
].name
),
19696 dwarf_form_name (die
->attrs
[i
].form
));
19698 switch (die
->attrs
[i
].form
)
19701 case DW_FORM_GNU_addr_index
:
19702 fprintf_unfiltered (f
, "address: ");
19703 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
19705 case DW_FORM_block2
:
19706 case DW_FORM_block4
:
19707 case DW_FORM_block
:
19708 case DW_FORM_block1
:
19709 fprintf_unfiltered (f
, "block: size %s",
19710 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19712 case DW_FORM_exprloc
:
19713 fprintf_unfiltered (f
, "expression: size %s",
19714 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19716 case DW_FORM_ref_addr
:
19717 fprintf_unfiltered (f
, "ref address: ");
19718 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19720 case DW_FORM_GNU_ref_alt
:
19721 fprintf_unfiltered (f
, "alt ref address: ");
19722 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19728 case DW_FORM_ref_udata
:
19729 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
19730 (long) (DW_UNSND (&die
->attrs
[i
])));
19732 case DW_FORM_data1
:
19733 case DW_FORM_data2
:
19734 case DW_FORM_data4
:
19735 case DW_FORM_data8
:
19736 case DW_FORM_udata
:
19737 case DW_FORM_sdata
:
19738 fprintf_unfiltered (f
, "constant: %s",
19739 pulongest (DW_UNSND (&die
->attrs
[i
])));
19741 case DW_FORM_sec_offset
:
19742 fprintf_unfiltered (f
, "section offset: %s",
19743 pulongest (DW_UNSND (&die
->attrs
[i
])));
19745 case DW_FORM_ref_sig8
:
19746 fprintf_unfiltered (f
, "signature: %s",
19747 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
19749 case DW_FORM_string
:
19751 case DW_FORM_GNU_str_index
:
19752 case DW_FORM_GNU_strp_alt
:
19753 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
19754 DW_STRING (&die
->attrs
[i
])
19755 ? DW_STRING (&die
->attrs
[i
]) : "",
19756 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
19759 if (DW_UNSND (&die
->attrs
[i
]))
19760 fprintf_unfiltered (f
, "flag: TRUE");
19762 fprintf_unfiltered (f
, "flag: FALSE");
19764 case DW_FORM_flag_present
:
19765 fprintf_unfiltered (f
, "flag: TRUE");
19767 case DW_FORM_indirect
:
19768 /* The reader will have reduced the indirect form to
19769 the "base form" so this form should not occur. */
19770 fprintf_unfiltered (f
,
19771 "unexpected attribute form: DW_FORM_indirect");
19774 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
19775 die
->attrs
[i
].form
);
19778 fprintf_unfiltered (f
, "\n");
19783 dump_die_for_error (struct die_info
*die
)
19785 dump_die_shallow (gdb_stderr
, 0, die
);
19789 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
19791 int indent
= level
* 4;
19793 gdb_assert (die
!= NULL
);
19795 if (level
>= max_level
)
19798 dump_die_shallow (f
, indent
, die
);
19800 if (die
->child
!= NULL
)
19802 print_spaces (indent
, f
);
19803 fprintf_unfiltered (f
, " Children:");
19804 if (level
+ 1 < max_level
)
19806 fprintf_unfiltered (f
, "\n");
19807 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
19811 fprintf_unfiltered (f
,
19812 " [not printed, max nesting level reached]\n");
19816 if (die
->sibling
!= NULL
&& level
> 0)
19818 dump_die_1 (f
, level
, max_level
, die
->sibling
);
19822 /* This is called from the pdie macro in gdbinit.in.
19823 It's not static so gcc will keep a copy callable from gdb. */
19826 dump_die (struct die_info
*die
, int max_level
)
19828 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
19832 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
19836 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
19842 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19846 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
19848 sect_offset retval
= { DW_UNSND (attr
) };
19850 if (attr_form_is_ref (attr
))
19853 retval
.sect_off
= 0;
19854 complaint (&symfile_complaints
,
19855 _("unsupported die ref attribute form: '%s'"),
19856 dwarf_form_name (attr
->form
));
19860 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19861 * the value held by the attribute is not constant. */
19864 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
19866 if (attr
->form
== DW_FORM_sdata
)
19867 return DW_SND (attr
);
19868 else if (attr
->form
== DW_FORM_udata
19869 || attr
->form
== DW_FORM_data1
19870 || attr
->form
== DW_FORM_data2
19871 || attr
->form
== DW_FORM_data4
19872 || attr
->form
== DW_FORM_data8
)
19873 return DW_UNSND (attr
);
19876 complaint (&symfile_complaints
,
19877 _("Attribute value is not a constant (%s)"),
19878 dwarf_form_name (attr
->form
));
19879 return default_value
;
19883 /* Follow reference or signature attribute ATTR of SRC_DIE.
19884 On entry *REF_CU is the CU of SRC_DIE.
19885 On exit *REF_CU is the CU of the result. */
19887 static struct die_info
*
19888 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
19889 struct dwarf2_cu
**ref_cu
)
19891 struct die_info
*die
;
19893 if (attr_form_is_ref (attr
))
19894 die
= follow_die_ref (src_die
, attr
, ref_cu
);
19895 else if (attr
->form
== DW_FORM_ref_sig8
)
19896 die
= follow_die_sig (src_die
, attr
, ref_cu
);
19899 dump_die_for_error (src_die
);
19900 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19901 objfile_name ((*ref_cu
)->objfile
));
19907 /* Follow reference OFFSET.
19908 On entry *REF_CU is the CU of the source die referencing OFFSET.
19909 On exit *REF_CU is the CU of the result.
19910 Returns NULL if OFFSET is invalid. */
19912 static struct die_info
*
19913 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
19914 struct dwarf2_cu
**ref_cu
)
19916 struct die_info temp_die
;
19917 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
19919 gdb_assert (cu
->per_cu
!= NULL
);
19923 if (cu
->per_cu
->is_debug_types
)
19925 /* .debug_types CUs cannot reference anything outside their CU.
19926 If they need to, they have to reference a signatured type via
19927 DW_FORM_ref_sig8. */
19928 if (! offset_in_cu_p (&cu
->header
, offset
))
19931 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
19932 || ! offset_in_cu_p (&cu
->header
, offset
))
19934 struct dwarf2_per_cu_data
*per_cu
;
19936 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
19939 /* If necessary, add it to the queue and load its DIEs. */
19940 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
19941 load_full_comp_unit (per_cu
, cu
->language
);
19943 target_cu
= per_cu
->cu
;
19945 else if (cu
->dies
== NULL
)
19947 /* We're loading full DIEs during partial symbol reading. */
19948 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
19949 load_full_comp_unit (cu
->per_cu
, language_minimal
);
19952 *ref_cu
= target_cu
;
19953 temp_die
.offset
= offset
;
19954 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
19957 /* Follow reference attribute ATTR of SRC_DIE.
19958 On entry *REF_CU is the CU of SRC_DIE.
19959 On exit *REF_CU is the CU of the result. */
19961 static struct die_info
*
19962 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
19963 struct dwarf2_cu
**ref_cu
)
19965 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
19966 struct dwarf2_cu
*cu
= *ref_cu
;
19967 struct die_info
*die
;
19969 die
= follow_die_offset (offset
,
19970 (attr
->form
== DW_FORM_GNU_ref_alt
19971 || cu
->per_cu
->is_dwz
),
19974 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19975 "at 0x%x [in module %s]"),
19976 offset
.sect_off
, src_die
->offset
.sect_off
,
19977 objfile_name (cu
->objfile
));
19982 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19983 Returned value is intended for DW_OP_call*. Returned
19984 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19986 struct dwarf2_locexpr_baton
19987 dwarf2_fetch_die_loc_sect_off (sect_offset offset
,
19988 struct dwarf2_per_cu_data
*per_cu
,
19989 CORE_ADDR (*get_frame_pc
) (void *baton
),
19992 struct dwarf2_cu
*cu
;
19993 struct die_info
*die
;
19994 struct attribute
*attr
;
19995 struct dwarf2_locexpr_baton retval
;
19997 dw2_setup (per_cu
->objfile
);
19999 if (per_cu
->cu
== NULL
)
20003 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20005 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20006 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20008 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20011 /* DWARF: "If there is no such attribute, then there is no effect.".
20012 DATA is ignored if SIZE is 0. */
20014 retval
.data
= NULL
;
20017 else if (attr_form_is_section_offset (attr
))
20019 struct dwarf2_loclist_baton loclist_baton
;
20020 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
20023 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
20025 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
20027 retval
.size
= size
;
20031 if (!attr_form_is_block (attr
))
20032 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
20033 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
20034 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20036 retval
.data
= DW_BLOCK (attr
)->data
;
20037 retval
.size
= DW_BLOCK (attr
)->size
;
20039 retval
.per_cu
= cu
->per_cu
;
20041 age_cached_comp_units ();
20046 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
20049 struct dwarf2_locexpr_baton
20050 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
20051 struct dwarf2_per_cu_data
*per_cu
,
20052 CORE_ADDR (*get_frame_pc
) (void *baton
),
20055 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
20057 return dwarf2_fetch_die_loc_sect_off (offset
, per_cu
, get_frame_pc
, baton
);
20060 /* Write a constant of a given type as target-ordered bytes into
20063 static const gdb_byte
*
20064 write_constant_as_bytes (struct obstack
*obstack
,
20065 enum bfd_endian byte_order
,
20072 *len
= TYPE_LENGTH (type
);
20073 result
= obstack_alloc (obstack
, *len
);
20074 store_unsigned_integer (result
, *len
, byte_order
, value
);
20079 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
20080 pointer to the constant bytes and set LEN to the length of the
20081 data. If memory is needed, allocate it on OBSTACK. If the DIE
20082 does not have a DW_AT_const_value, return NULL. */
20085 dwarf2_fetch_constant_bytes (sect_offset offset
,
20086 struct dwarf2_per_cu_data
*per_cu
,
20087 struct obstack
*obstack
,
20090 struct dwarf2_cu
*cu
;
20091 struct die_info
*die
;
20092 struct attribute
*attr
;
20093 const gdb_byte
*result
= NULL
;
20096 enum bfd_endian byte_order
;
20098 dw2_setup (per_cu
->objfile
);
20100 if (per_cu
->cu
== NULL
)
20104 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20106 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20107 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20110 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20114 byte_order
= (bfd_big_endian (per_cu
->objfile
->obfd
)
20115 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
20117 switch (attr
->form
)
20120 case DW_FORM_GNU_addr_index
:
20124 *len
= cu
->header
.addr_size
;
20125 tem
= obstack_alloc (obstack
, *len
);
20126 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
20130 case DW_FORM_string
:
20132 case DW_FORM_GNU_str_index
:
20133 case DW_FORM_GNU_strp_alt
:
20134 /* DW_STRING is already allocated on the objfile obstack, point
20136 result
= (const gdb_byte
*) DW_STRING (attr
);
20137 *len
= strlen (DW_STRING (attr
));
20139 case DW_FORM_block1
:
20140 case DW_FORM_block2
:
20141 case DW_FORM_block4
:
20142 case DW_FORM_block
:
20143 case DW_FORM_exprloc
:
20144 result
= DW_BLOCK (attr
)->data
;
20145 *len
= DW_BLOCK (attr
)->size
;
20148 /* The DW_AT_const_value attributes are supposed to carry the
20149 symbol's value "represented as it would be on the target
20150 architecture." By the time we get here, it's already been
20151 converted to host endianness, so we just need to sign- or
20152 zero-extend it as appropriate. */
20153 case DW_FORM_data1
:
20154 type
= die_type (die
, cu
);
20155 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
20156 if (result
== NULL
)
20157 result
= write_constant_as_bytes (obstack
, byte_order
,
20160 case DW_FORM_data2
:
20161 type
= die_type (die
, cu
);
20162 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
20163 if (result
== NULL
)
20164 result
= write_constant_as_bytes (obstack
, byte_order
,
20167 case DW_FORM_data4
:
20168 type
= die_type (die
, cu
);
20169 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
20170 if (result
== NULL
)
20171 result
= write_constant_as_bytes (obstack
, byte_order
,
20174 case DW_FORM_data8
:
20175 type
= die_type (die
, cu
);
20176 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
20177 if (result
== NULL
)
20178 result
= write_constant_as_bytes (obstack
, byte_order
,
20182 case DW_FORM_sdata
:
20183 type
= die_type (die
, cu
);
20184 result
= write_constant_as_bytes (obstack
, byte_order
,
20185 type
, DW_SND (attr
), len
);
20188 case DW_FORM_udata
:
20189 type
= die_type (die
, cu
);
20190 result
= write_constant_as_bytes (obstack
, byte_order
,
20191 type
, DW_UNSND (attr
), len
);
20195 complaint (&symfile_complaints
,
20196 _("unsupported const value attribute form: '%s'"),
20197 dwarf_form_name (attr
->form
));
20204 /* Return the type of the DIE at DIE_OFFSET in the CU named by
20208 dwarf2_get_die_type (cu_offset die_offset
,
20209 struct dwarf2_per_cu_data
*per_cu
)
20211 sect_offset die_offset_sect
;
20213 dw2_setup (per_cu
->objfile
);
20215 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
20216 return get_die_type_at_offset (die_offset_sect
, per_cu
);
20219 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
20220 On entry *REF_CU is the CU of SRC_DIE.
20221 On exit *REF_CU is the CU of the result.
20222 Returns NULL if the referenced DIE isn't found. */
20224 static struct die_info
*
20225 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
20226 struct dwarf2_cu
**ref_cu
)
20228 struct objfile
*objfile
= (*ref_cu
)->objfile
;
20229 struct die_info temp_die
;
20230 struct dwarf2_cu
*sig_cu
;
20231 struct die_info
*die
;
20233 /* While it might be nice to assert sig_type->type == NULL here,
20234 we can get here for DW_AT_imported_declaration where we need
20235 the DIE not the type. */
20237 /* If necessary, add it to the queue and load its DIEs. */
20239 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
20240 read_signatured_type (sig_type
);
20242 sig_cu
= sig_type
->per_cu
.cu
;
20243 gdb_assert (sig_cu
!= NULL
);
20244 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
20245 temp_die
.offset
= sig_type
->type_offset_in_section
;
20246 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
20247 temp_die
.offset
.sect_off
);
20250 /* For .gdb_index version 7 keep track of included TUs.
20251 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
20252 if (dwarf2_per_objfile
->index_table
!= NULL
20253 && dwarf2_per_objfile
->index_table
->version
<= 7)
20255 VEC_safe_push (dwarf2_per_cu_ptr
,
20256 (*ref_cu
)->per_cu
->imported_symtabs
,
20267 /* Follow signatured type referenced by ATTR in SRC_DIE.
20268 On entry *REF_CU is the CU of SRC_DIE.
20269 On exit *REF_CU is the CU of the result.
20270 The result is the DIE of the type.
20271 If the referenced type cannot be found an error is thrown. */
20273 static struct die_info
*
20274 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
20275 struct dwarf2_cu
**ref_cu
)
20277 ULONGEST signature
= DW_SIGNATURE (attr
);
20278 struct signatured_type
*sig_type
;
20279 struct die_info
*die
;
20281 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
20283 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
20284 /* sig_type will be NULL if the signatured type is missing from
20286 if (sig_type
== NULL
)
20288 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
20289 " from DIE at 0x%x [in module %s]"),
20290 hex_string (signature
), src_die
->offset
.sect_off
,
20291 objfile_name ((*ref_cu
)->objfile
));
20294 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
20297 dump_die_for_error (src_die
);
20298 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
20299 " from DIE at 0x%x [in module %s]"),
20300 hex_string (signature
), src_die
->offset
.sect_off
,
20301 objfile_name ((*ref_cu
)->objfile
));
20307 /* Get the type specified by SIGNATURE referenced in DIE/CU,
20308 reading in and processing the type unit if necessary. */
20310 static struct type
*
20311 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
20312 struct dwarf2_cu
*cu
)
20314 struct signatured_type
*sig_type
;
20315 struct dwarf2_cu
*type_cu
;
20316 struct die_info
*type_die
;
20319 sig_type
= lookup_signatured_type (cu
, signature
);
20320 /* sig_type will be NULL if the signatured type is missing from
20322 if (sig_type
== NULL
)
20324 complaint (&symfile_complaints
,
20325 _("Dwarf Error: Cannot find signatured DIE %s referenced"
20326 " from DIE at 0x%x [in module %s]"),
20327 hex_string (signature
), die
->offset
.sect_off
,
20328 objfile_name (dwarf2_per_objfile
->objfile
));
20329 return build_error_marker_type (cu
, die
);
20332 /* If we already know the type we're done. */
20333 if (sig_type
->type
!= NULL
)
20334 return sig_type
->type
;
20337 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
20338 if (type_die
!= NULL
)
20340 /* N.B. We need to call get_die_type to ensure only one type for this DIE
20341 is created. This is important, for example, because for c++ classes
20342 we need TYPE_NAME set which is only done by new_symbol. Blech. */
20343 type
= read_type_die (type_die
, type_cu
);
20346 complaint (&symfile_complaints
,
20347 _("Dwarf Error: Cannot build signatured type %s"
20348 " referenced from DIE at 0x%x [in module %s]"),
20349 hex_string (signature
), die
->offset
.sect_off
,
20350 objfile_name (dwarf2_per_objfile
->objfile
));
20351 type
= build_error_marker_type (cu
, die
);
20356 complaint (&symfile_complaints
,
20357 _("Dwarf Error: Problem reading signatured DIE %s referenced"
20358 " from DIE at 0x%x [in module %s]"),
20359 hex_string (signature
), die
->offset
.sect_off
,
20360 objfile_name (dwarf2_per_objfile
->objfile
));
20361 type
= build_error_marker_type (cu
, die
);
20363 sig_type
->type
= type
;
20368 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
20369 reading in and processing the type unit if necessary. */
20371 static struct type
*
20372 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
20373 struct dwarf2_cu
*cu
) /* ARI: editCase function */
20375 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
20376 if (attr_form_is_ref (attr
))
20378 struct dwarf2_cu
*type_cu
= cu
;
20379 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
20381 return read_type_die (type_die
, type_cu
);
20383 else if (attr
->form
== DW_FORM_ref_sig8
)
20385 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
20389 complaint (&symfile_complaints
,
20390 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
20391 " at 0x%x [in module %s]"),
20392 dwarf_form_name (attr
->form
), die
->offset
.sect_off
,
20393 objfile_name (dwarf2_per_objfile
->objfile
));
20394 return build_error_marker_type (cu
, die
);
20398 /* Load the DIEs associated with type unit PER_CU into memory. */
20401 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
20403 struct signatured_type
*sig_type
;
20405 /* Caller is responsible for ensuring type_unit_groups don't get here. */
20406 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
20408 /* We have the per_cu, but we need the signatured_type.
20409 Fortunately this is an easy translation. */
20410 gdb_assert (per_cu
->is_debug_types
);
20411 sig_type
= (struct signatured_type
*) per_cu
;
20413 gdb_assert (per_cu
->cu
== NULL
);
20415 read_signatured_type (sig_type
);
20417 gdb_assert (per_cu
->cu
!= NULL
);
20420 /* die_reader_func for read_signatured_type.
20421 This is identical to load_full_comp_unit_reader,
20422 but is kept separate for now. */
20425 read_signatured_type_reader (const struct die_reader_specs
*reader
,
20426 const gdb_byte
*info_ptr
,
20427 struct die_info
*comp_unit_die
,
20431 struct dwarf2_cu
*cu
= reader
->cu
;
20433 gdb_assert (cu
->die_hash
== NULL
);
20435 htab_create_alloc_ex (cu
->header
.length
/ 12,
20439 &cu
->comp_unit_obstack
,
20440 hashtab_obstack_allocate
,
20441 dummy_obstack_deallocate
);
20444 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
20445 &info_ptr
, comp_unit_die
);
20446 cu
->dies
= comp_unit_die
;
20447 /* comp_unit_die is not stored in die_hash, no need. */
20449 /* We try not to read any attributes in this function, because not
20450 all CUs needed for references have been loaded yet, and symbol
20451 table processing isn't initialized. But we have to set the CU language,
20452 or we won't be able to build types correctly.
20453 Similarly, if we do not read the producer, we can not apply
20454 producer-specific interpretation. */
20455 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
20458 /* Read in a signatured type and build its CU and DIEs.
20459 If the type is a stub for the real type in a DWO file,
20460 read in the real type from the DWO file as well. */
20463 read_signatured_type (struct signatured_type
*sig_type
)
20465 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
20467 gdb_assert (per_cu
->is_debug_types
);
20468 gdb_assert (per_cu
->cu
== NULL
);
20470 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
20471 read_signatured_type_reader
, NULL
);
20472 sig_type
->per_cu
.tu_read
= 1;
20475 /* Decode simple location descriptions.
20476 Given a pointer to a dwarf block that defines a location, compute
20477 the location and return the value.
20479 NOTE drow/2003-11-18: This function is called in two situations
20480 now: for the address of static or global variables (partial symbols
20481 only) and for offsets into structures which are expected to be
20482 (more or less) constant. The partial symbol case should go away,
20483 and only the constant case should remain. That will let this
20484 function complain more accurately. A few special modes are allowed
20485 without complaint for global variables (for instance, global
20486 register values and thread-local values).
20488 A location description containing no operations indicates that the
20489 object is optimized out. The return value is 0 for that case.
20490 FIXME drow/2003-11-16: No callers check for this case any more; soon all
20491 callers will only want a very basic result and this can become a
20494 Note that stack[0] is unused except as a default error return. */
20497 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
20499 struct objfile
*objfile
= cu
->objfile
;
20501 size_t size
= blk
->size
;
20502 const gdb_byte
*data
= blk
->data
;
20503 CORE_ADDR stack
[64];
20505 unsigned int bytes_read
, unsnd
;
20511 stack
[++stacki
] = 0;
20550 stack
[++stacki
] = op
- DW_OP_lit0
;
20585 stack
[++stacki
] = op
- DW_OP_reg0
;
20587 dwarf2_complex_location_expr_complaint ();
20591 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
20593 stack
[++stacki
] = unsnd
;
20595 dwarf2_complex_location_expr_complaint ();
20599 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
20604 case DW_OP_const1u
:
20605 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
20609 case DW_OP_const1s
:
20610 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
20614 case DW_OP_const2u
:
20615 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
20619 case DW_OP_const2s
:
20620 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
20624 case DW_OP_const4u
:
20625 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
20629 case DW_OP_const4s
:
20630 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
20634 case DW_OP_const8u
:
20635 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
20640 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
20646 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
20651 stack
[stacki
+ 1] = stack
[stacki
];
20656 stack
[stacki
- 1] += stack
[stacki
];
20660 case DW_OP_plus_uconst
:
20661 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
20667 stack
[stacki
- 1] -= stack
[stacki
];
20672 /* If we're not the last op, then we definitely can't encode
20673 this using GDB's address_class enum. This is valid for partial
20674 global symbols, although the variable's address will be bogus
20677 dwarf2_complex_location_expr_complaint ();
20680 case DW_OP_GNU_push_tls_address
:
20681 /* The top of the stack has the offset from the beginning
20682 of the thread control block at which the variable is located. */
20683 /* Nothing should follow this operator, so the top of stack would
20685 /* This is valid for partial global symbols, but the variable's
20686 address will be bogus in the psymtab. Make it always at least
20687 non-zero to not look as a variable garbage collected by linker
20688 which have DW_OP_addr 0. */
20690 dwarf2_complex_location_expr_complaint ();
20694 case DW_OP_GNU_uninit
:
20697 case DW_OP_GNU_addr_index
:
20698 case DW_OP_GNU_const_index
:
20699 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
20706 const char *name
= get_DW_OP_name (op
);
20709 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
20712 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
20716 return (stack
[stacki
]);
20719 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20720 outside of the allocated space. Also enforce minimum>0. */
20721 if (stacki
>= ARRAY_SIZE (stack
) - 1)
20723 complaint (&symfile_complaints
,
20724 _("location description stack overflow"));
20730 complaint (&symfile_complaints
,
20731 _("location description stack underflow"));
20735 return (stack
[stacki
]);
20738 /* memory allocation interface */
20740 static struct dwarf_block
*
20741 dwarf_alloc_block (struct dwarf2_cu
*cu
)
20743 struct dwarf_block
*blk
;
20745 blk
= (struct dwarf_block
*)
20746 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
20750 static struct die_info
*
20751 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
20753 struct die_info
*die
;
20754 size_t size
= sizeof (struct die_info
);
20757 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
20759 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
20760 memset (die
, 0, sizeof (struct die_info
));
20765 /* Macro support. */
20767 /* Return file name relative to the compilation directory of file number I in
20768 *LH's file name table. The result is allocated using xmalloc; the caller is
20769 responsible for freeing it. */
20772 file_file_name (int file
, struct line_header
*lh
)
20774 /* Is the file number a valid index into the line header's file name
20775 table? Remember that file numbers start with one, not zero. */
20776 if (1 <= file
&& file
<= lh
->num_file_names
)
20778 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
20780 if (IS_ABSOLUTE_PATH (fe
->name
) || fe
->dir_index
== 0
20781 || lh
->include_dirs
== NULL
)
20782 return xstrdup (fe
->name
);
20783 return concat (lh
->include_dirs
[fe
->dir_index
- 1], SLASH_STRING
,
20788 /* The compiler produced a bogus file number. We can at least
20789 record the macro definitions made in the file, even if we
20790 won't be able to find the file by name. */
20791 char fake_name
[80];
20793 xsnprintf (fake_name
, sizeof (fake_name
),
20794 "<bad macro file number %d>", file
);
20796 complaint (&symfile_complaints
,
20797 _("bad file number in macro information (%d)"),
20800 return xstrdup (fake_name
);
20804 /* Return the full name of file number I in *LH's file name table.
20805 Use COMP_DIR as the name of the current directory of the
20806 compilation. The result is allocated using xmalloc; the caller is
20807 responsible for freeing it. */
20809 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
20811 /* Is the file number a valid index into the line header's file name
20812 table? Remember that file numbers start with one, not zero. */
20813 if (1 <= file
&& file
<= lh
->num_file_names
)
20815 char *relative
= file_file_name (file
, lh
);
20817 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
20819 return reconcat (relative
, comp_dir
, SLASH_STRING
, relative
, NULL
);
20822 return file_file_name (file
, lh
);
20826 static struct macro_source_file
*
20827 macro_start_file (int file
, int line
,
20828 struct macro_source_file
*current_file
,
20829 struct line_header
*lh
)
20831 /* File name relative to the compilation directory of this source file. */
20832 char *file_name
= file_file_name (file
, lh
);
20834 if (! current_file
)
20836 /* Note: We don't create a macro table for this compilation unit
20837 at all until we actually get a filename. */
20838 struct macro_table
*macro_table
= get_macro_table ();
20840 /* If we have no current file, then this must be the start_file
20841 directive for the compilation unit's main source file. */
20842 current_file
= macro_set_main (macro_table
, file_name
);
20843 macro_define_special (macro_table
);
20846 current_file
= macro_include (current_file
, line
, file_name
);
20850 return current_file
;
20854 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20855 followed by a null byte. */
20857 copy_string (const char *buf
, int len
)
20859 char *s
= xmalloc (len
+ 1);
20861 memcpy (s
, buf
, len
);
20867 static const char *
20868 consume_improper_spaces (const char *p
, const char *body
)
20872 complaint (&symfile_complaints
,
20873 _("macro definition contains spaces "
20874 "in formal argument list:\n`%s'"),
20886 parse_macro_definition (struct macro_source_file
*file
, int line
,
20891 /* The body string takes one of two forms. For object-like macro
20892 definitions, it should be:
20894 <macro name> " " <definition>
20896 For function-like macro definitions, it should be:
20898 <macro name> "() " <definition>
20900 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20902 Spaces may appear only where explicitly indicated, and in the
20905 The Dwarf 2 spec says that an object-like macro's name is always
20906 followed by a space, but versions of GCC around March 2002 omit
20907 the space when the macro's definition is the empty string.
20909 The Dwarf 2 spec says that there should be no spaces between the
20910 formal arguments in a function-like macro's formal argument list,
20911 but versions of GCC around March 2002 include spaces after the
20915 /* Find the extent of the macro name. The macro name is terminated
20916 by either a space or null character (for an object-like macro) or
20917 an opening paren (for a function-like macro). */
20918 for (p
= body
; *p
; p
++)
20919 if (*p
== ' ' || *p
== '(')
20922 if (*p
== ' ' || *p
== '\0')
20924 /* It's an object-like macro. */
20925 int name_len
= p
- body
;
20926 char *name
= copy_string (body
, name_len
);
20927 const char *replacement
;
20930 replacement
= body
+ name_len
+ 1;
20933 dwarf2_macro_malformed_definition_complaint (body
);
20934 replacement
= body
+ name_len
;
20937 macro_define_object (file
, line
, name
, replacement
);
20941 else if (*p
== '(')
20943 /* It's a function-like macro. */
20944 char *name
= copy_string (body
, p
- body
);
20947 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
20951 p
= consume_improper_spaces (p
, body
);
20953 /* Parse the formal argument list. */
20954 while (*p
&& *p
!= ')')
20956 /* Find the extent of the current argument name. */
20957 const char *arg_start
= p
;
20959 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
20962 if (! *p
|| p
== arg_start
)
20963 dwarf2_macro_malformed_definition_complaint (body
);
20966 /* Make sure argv has room for the new argument. */
20967 if (argc
>= argv_size
)
20970 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
20973 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
20976 p
= consume_improper_spaces (p
, body
);
20978 /* Consume the comma, if present. */
20983 p
= consume_improper_spaces (p
, body
);
20992 /* Perfectly formed definition, no complaints. */
20993 macro_define_function (file
, line
, name
,
20994 argc
, (const char **) argv
,
20996 else if (*p
== '\0')
20998 /* Complain, but do define it. */
20999 dwarf2_macro_malformed_definition_complaint (body
);
21000 macro_define_function (file
, line
, name
,
21001 argc
, (const char **) argv
,
21005 /* Just complain. */
21006 dwarf2_macro_malformed_definition_complaint (body
);
21009 /* Just complain. */
21010 dwarf2_macro_malformed_definition_complaint (body
);
21016 for (i
= 0; i
< argc
; i
++)
21022 dwarf2_macro_malformed_definition_complaint (body
);
21025 /* Skip some bytes from BYTES according to the form given in FORM.
21026 Returns the new pointer. */
21028 static const gdb_byte
*
21029 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
21030 enum dwarf_form form
,
21031 unsigned int offset_size
,
21032 struct dwarf2_section_info
*section
)
21034 unsigned int bytes_read
;
21038 case DW_FORM_data1
:
21043 case DW_FORM_data2
:
21047 case DW_FORM_data4
:
21051 case DW_FORM_data8
:
21055 case DW_FORM_string
:
21056 read_direct_string (abfd
, bytes
, &bytes_read
);
21057 bytes
+= bytes_read
;
21060 case DW_FORM_sec_offset
:
21062 case DW_FORM_GNU_strp_alt
:
21063 bytes
+= offset_size
;
21066 case DW_FORM_block
:
21067 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
21068 bytes
+= bytes_read
;
21071 case DW_FORM_block1
:
21072 bytes
+= 1 + read_1_byte (abfd
, bytes
);
21074 case DW_FORM_block2
:
21075 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
21077 case DW_FORM_block4
:
21078 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
21081 case DW_FORM_sdata
:
21082 case DW_FORM_udata
:
21083 case DW_FORM_GNU_addr_index
:
21084 case DW_FORM_GNU_str_index
:
21085 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
21088 dwarf2_section_buffer_overflow_complaint (section
);
21096 complaint (&symfile_complaints
,
21097 _("invalid form 0x%x in `%s'"),
21098 form
, get_section_name (section
));
21106 /* A helper for dwarf_decode_macros that handles skipping an unknown
21107 opcode. Returns an updated pointer to the macro data buffer; or,
21108 on error, issues a complaint and returns NULL. */
21110 static const gdb_byte
*
21111 skip_unknown_opcode (unsigned int opcode
,
21112 const gdb_byte
**opcode_definitions
,
21113 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21115 unsigned int offset_size
,
21116 struct dwarf2_section_info
*section
)
21118 unsigned int bytes_read
, i
;
21120 const gdb_byte
*defn
;
21122 if (opcode_definitions
[opcode
] == NULL
)
21124 complaint (&symfile_complaints
,
21125 _("unrecognized DW_MACFINO opcode 0x%x"),
21130 defn
= opcode_definitions
[opcode
];
21131 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
21132 defn
+= bytes_read
;
21134 for (i
= 0; i
< arg
; ++i
)
21136 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
, defn
[i
], offset_size
,
21138 if (mac_ptr
== NULL
)
21140 /* skip_form_bytes already issued the complaint. */
21148 /* A helper function which parses the header of a macro section.
21149 If the macro section is the extended (for now called "GNU") type,
21150 then this updates *OFFSET_SIZE. Returns a pointer to just after
21151 the header, or issues a complaint and returns NULL on error. */
21153 static const gdb_byte
*
21154 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
21156 const gdb_byte
*mac_ptr
,
21157 unsigned int *offset_size
,
21158 int section_is_gnu
)
21160 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
21162 if (section_is_gnu
)
21164 unsigned int version
, flags
;
21166 version
= read_2_bytes (abfd
, mac_ptr
);
21169 complaint (&symfile_complaints
,
21170 _("unrecognized version `%d' in .debug_macro section"),
21176 flags
= read_1_byte (abfd
, mac_ptr
);
21178 *offset_size
= (flags
& 1) ? 8 : 4;
21180 if ((flags
& 2) != 0)
21181 /* We don't need the line table offset. */
21182 mac_ptr
+= *offset_size
;
21184 /* Vendor opcode descriptions. */
21185 if ((flags
& 4) != 0)
21187 unsigned int i
, count
;
21189 count
= read_1_byte (abfd
, mac_ptr
);
21191 for (i
= 0; i
< count
; ++i
)
21193 unsigned int opcode
, bytes_read
;
21196 opcode
= read_1_byte (abfd
, mac_ptr
);
21198 opcode_definitions
[opcode
] = mac_ptr
;
21199 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21200 mac_ptr
+= bytes_read
;
21209 /* A helper for dwarf_decode_macros that handles the GNU extensions,
21210 including DW_MACRO_GNU_transparent_include. */
21213 dwarf_decode_macro_bytes (bfd
*abfd
,
21214 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21215 struct macro_source_file
*current_file
,
21216 struct line_header
*lh
,
21217 struct dwarf2_section_info
*section
,
21218 int section_is_gnu
, int section_is_dwz
,
21219 unsigned int offset_size
,
21220 htab_t include_hash
)
21222 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21223 enum dwarf_macro_record_type macinfo_type
;
21224 int at_commandline
;
21225 const gdb_byte
*opcode_definitions
[256];
21227 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21228 &offset_size
, section_is_gnu
);
21229 if (mac_ptr
== NULL
)
21231 /* We already issued a complaint. */
21235 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
21236 GDB is still reading the definitions from command line. First
21237 DW_MACINFO_start_file will need to be ignored as it was already executed
21238 to create CURRENT_FILE for the main source holding also the command line
21239 definitions. On first met DW_MACINFO_start_file this flag is reset to
21240 normally execute all the remaining DW_MACINFO_start_file macinfos. */
21242 at_commandline
= 1;
21246 /* Do we at least have room for a macinfo type byte? */
21247 if (mac_ptr
>= mac_end
)
21249 dwarf2_section_buffer_overflow_complaint (section
);
21253 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
21256 /* Note that we rely on the fact that the corresponding GNU and
21257 DWARF constants are the same. */
21258 switch (macinfo_type
)
21260 /* A zero macinfo type indicates the end of the macro
21265 case DW_MACRO_GNU_define
:
21266 case DW_MACRO_GNU_undef
:
21267 case DW_MACRO_GNU_define_indirect
:
21268 case DW_MACRO_GNU_undef_indirect
:
21269 case DW_MACRO_GNU_define_indirect_alt
:
21270 case DW_MACRO_GNU_undef_indirect_alt
:
21272 unsigned int bytes_read
;
21277 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21278 mac_ptr
+= bytes_read
;
21280 if (macinfo_type
== DW_MACRO_GNU_define
21281 || macinfo_type
== DW_MACRO_GNU_undef
)
21283 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21284 mac_ptr
+= bytes_read
;
21288 LONGEST str_offset
;
21290 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21291 mac_ptr
+= offset_size
;
21293 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
21294 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
21297 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21299 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
21302 body
= read_indirect_string_at_offset (abfd
, str_offset
);
21305 is_define
= (macinfo_type
== DW_MACRO_GNU_define
21306 || macinfo_type
== DW_MACRO_GNU_define_indirect
21307 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
21308 if (! current_file
)
21310 /* DWARF violation as no main source is present. */
21311 complaint (&symfile_complaints
,
21312 _("debug info with no main source gives macro %s "
21314 is_define
? _("definition") : _("undefinition"),
21318 if ((line
== 0 && !at_commandline
)
21319 || (line
!= 0 && at_commandline
))
21320 complaint (&symfile_complaints
,
21321 _("debug info gives %s macro %s with %s line %d: %s"),
21322 at_commandline
? _("command-line") : _("in-file"),
21323 is_define
? _("definition") : _("undefinition"),
21324 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
21327 parse_macro_definition (current_file
, line
, body
);
21330 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
21331 || macinfo_type
== DW_MACRO_GNU_undef_indirect
21332 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
21333 macro_undef (current_file
, line
, body
);
21338 case DW_MACRO_GNU_start_file
:
21340 unsigned int bytes_read
;
21343 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21344 mac_ptr
+= bytes_read
;
21345 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21346 mac_ptr
+= bytes_read
;
21348 if ((line
== 0 && !at_commandline
)
21349 || (line
!= 0 && at_commandline
))
21350 complaint (&symfile_complaints
,
21351 _("debug info gives source %d included "
21352 "from %s at %s line %d"),
21353 file
, at_commandline
? _("command-line") : _("file"),
21354 line
== 0 ? _("zero") : _("non-zero"), line
);
21356 if (at_commandline
)
21358 /* This DW_MACRO_GNU_start_file was executed in the
21360 at_commandline
= 0;
21363 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21367 case DW_MACRO_GNU_end_file
:
21368 if (! current_file
)
21369 complaint (&symfile_complaints
,
21370 _("macro debug info has an unmatched "
21371 "`close_file' directive"));
21374 current_file
= current_file
->included_by
;
21375 if (! current_file
)
21377 enum dwarf_macro_record_type next_type
;
21379 /* GCC circa March 2002 doesn't produce the zero
21380 type byte marking the end of the compilation
21381 unit. Complain if it's not there, but exit no
21384 /* Do we at least have room for a macinfo type byte? */
21385 if (mac_ptr
>= mac_end
)
21387 dwarf2_section_buffer_overflow_complaint (section
);
21391 /* We don't increment mac_ptr here, so this is just
21393 next_type
= read_1_byte (abfd
, mac_ptr
);
21394 if (next_type
!= 0)
21395 complaint (&symfile_complaints
,
21396 _("no terminating 0-type entry for "
21397 "macros in `.debug_macinfo' section"));
21404 case DW_MACRO_GNU_transparent_include
:
21405 case DW_MACRO_GNU_transparent_include_alt
:
21409 bfd
*include_bfd
= abfd
;
21410 struct dwarf2_section_info
*include_section
= section
;
21411 struct dwarf2_section_info alt_section
;
21412 const gdb_byte
*include_mac_end
= mac_end
;
21413 int is_dwz
= section_is_dwz
;
21414 const gdb_byte
*new_mac_ptr
;
21416 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21417 mac_ptr
+= offset_size
;
21419 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
21421 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21423 dwarf2_read_section (objfile
, &dwz
->macro
);
21425 include_section
= &dwz
->macro
;
21426 include_bfd
= get_section_bfd_owner (include_section
);
21427 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
21431 new_mac_ptr
= include_section
->buffer
+ offset
;
21432 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
21436 /* This has actually happened; see
21437 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
21438 complaint (&symfile_complaints
,
21439 _("recursive DW_MACRO_GNU_transparent_include in "
21440 ".debug_macro section"));
21444 *slot
= (void *) new_mac_ptr
;
21446 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
21447 include_mac_end
, current_file
, lh
,
21448 section
, section_is_gnu
, is_dwz
,
21449 offset_size
, include_hash
);
21451 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
21456 case DW_MACINFO_vendor_ext
:
21457 if (!section_is_gnu
)
21459 unsigned int bytes_read
;
21462 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21463 mac_ptr
+= bytes_read
;
21464 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21465 mac_ptr
+= bytes_read
;
21467 /* We don't recognize any vendor extensions. */
21473 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21474 mac_ptr
, mac_end
, abfd
, offset_size
,
21476 if (mac_ptr
== NULL
)
21480 } while (macinfo_type
!= 0);
21484 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
21485 int section_is_gnu
)
21487 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21488 struct line_header
*lh
= cu
->line_header
;
21490 const gdb_byte
*mac_ptr
, *mac_end
;
21491 struct macro_source_file
*current_file
= 0;
21492 enum dwarf_macro_record_type macinfo_type
;
21493 unsigned int offset_size
= cu
->header
.offset_size
;
21494 const gdb_byte
*opcode_definitions
[256];
21495 struct cleanup
*cleanup
;
21496 htab_t include_hash
;
21498 struct dwarf2_section_info
*section
;
21499 const char *section_name
;
21501 if (cu
->dwo_unit
!= NULL
)
21503 if (section_is_gnu
)
21505 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
21506 section_name
= ".debug_macro.dwo";
21510 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
21511 section_name
= ".debug_macinfo.dwo";
21516 if (section_is_gnu
)
21518 section
= &dwarf2_per_objfile
->macro
;
21519 section_name
= ".debug_macro";
21523 section
= &dwarf2_per_objfile
->macinfo
;
21524 section_name
= ".debug_macinfo";
21528 dwarf2_read_section (objfile
, section
);
21529 if (section
->buffer
== NULL
)
21531 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
21534 abfd
= get_section_bfd_owner (section
);
21536 /* First pass: Find the name of the base filename.
21537 This filename is needed in order to process all macros whose definition
21538 (or undefinition) comes from the command line. These macros are defined
21539 before the first DW_MACINFO_start_file entry, and yet still need to be
21540 associated to the base file.
21542 To determine the base file name, we scan the macro definitions until we
21543 reach the first DW_MACINFO_start_file entry. We then initialize
21544 CURRENT_FILE accordingly so that any macro definition found before the
21545 first DW_MACINFO_start_file can still be associated to the base file. */
21547 mac_ptr
= section
->buffer
+ offset
;
21548 mac_end
= section
->buffer
+ section
->size
;
21550 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21551 &offset_size
, section_is_gnu
);
21552 if (mac_ptr
== NULL
)
21554 /* We already issued a complaint. */
21560 /* Do we at least have room for a macinfo type byte? */
21561 if (mac_ptr
>= mac_end
)
21563 /* Complaint is printed during the second pass as GDB will probably
21564 stop the first pass earlier upon finding
21565 DW_MACINFO_start_file. */
21569 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
21572 /* Note that we rely on the fact that the corresponding GNU and
21573 DWARF constants are the same. */
21574 switch (macinfo_type
)
21576 /* A zero macinfo type indicates the end of the macro
21581 case DW_MACRO_GNU_define
:
21582 case DW_MACRO_GNU_undef
:
21583 /* Only skip the data by MAC_PTR. */
21585 unsigned int bytes_read
;
21587 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21588 mac_ptr
+= bytes_read
;
21589 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21590 mac_ptr
+= bytes_read
;
21594 case DW_MACRO_GNU_start_file
:
21596 unsigned int bytes_read
;
21599 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21600 mac_ptr
+= bytes_read
;
21601 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21602 mac_ptr
+= bytes_read
;
21604 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21608 case DW_MACRO_GNU_end_file
:
21609 /* No data to skip by MAC_PTR. */
21612 case DW_MACRO_GNU_define_indirect
:
21613 case DW_MACRO_GNU_undef_indirect
:
21614 case DW_MACRO_GNU_define_indirect_alt
:
21615 case DW_MACRO_GNU_undef_indirect_alt
:
21617 unsigned int bytes_read
;
21619 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21620 mac_ptr
+= bytes_read
;
21621 mac_ptr
+= offset_size
;
21625 case DW_MACRO_GNU_transparent_include
:
21626 case DW_MACRO_GNU_transparent_include_alt
:
21627 /* Note that, according to the spec, a transparent include
21628 chain cannot call DW_MACRO_GNU_start_file. So, we can just
21629 skip this opcode. */
21630 mac_ptr
+= offset_size
;
21633 case DW_MACINFO_vendor_ext
:
21634 /* Only skip the data by MAC_PTR. */
21635 if (!section_is_gnu
)
21637 unsigned int bytes_read
;
21639 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21640 mac_ptr
+= bytes_read
;
21641 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21642 mac_ptr
+= bytes_read
;
21647 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21648 mac_ptr
, mac_end
, abfd
, offset_size
,
21650 if (mac_ptr
== NULL
)
21654 } while (macinfo_type
!= 0 && current_file
== NULL
);
21656 /* Second pass: Process all entries.
21658 Use the AT_COMMAND_LINE flag to determine whether we are still processing
21659 command-line macro definitions/undefinitions. This flag is unset when we
21660 reach the first DW_MACINFO_start_file entry. */
21662 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
21663 NULL
, xcalloc
, xfree
);
21664 cleanup
= make_cleanup_htab_delete (include_hash
);
21665 mac_ptr
= section
->buffer
+ offset
;
21666 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
21667 *slot
= (void *) mac_ptr
;
21668 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
21669 current_file
, lh
, section
,
21670 section_is_gnu
, 0, offset_size
, include_hash
);
21671 do_cleanups (cleanup
);
21674 /* Check if the attribute's form is a DW_FORM_block*
21675 if so return true else false. */
21678 attr_form_is_block (const struct attribute
*attr
)
21680 return (attr
== NULL
? 0 :
21681 attr
->form
== DW_FORM_block1
21682 || attr
->form
== DW_FORM_block2
21683 || attr
->form
== DW_FORM_block4
21684 || attr
->form
== DW_FORM_block
21685 || attr
->form
== DW_FORM_exprloc
);
21688 /* Return non-zero if ATTR's value is a section offset --- classes
21689 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21690 You may use DW_UNSND (attr) to retrieve such offsets.
21692 Section 7.5.4, "Attribute Encodings", explains that no attribute
21693 may have a value that belongs to more than one of these classes; it
21694 would be ambiguous if we did, because we use the same forms for all
21698 attr_form_is_section_offset (const struct attribute
*attr
)
21700 return (attr
->form
== DW_FORM_data4
21701 || attr
->form
== DW_FORM_data8
21702 || attr
->form
== DW_FORM_sec_offset
);
21705 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21706 zero otherwise. When this function returns true, you can apply
21707 dwarf2_get_attr_constant_value to it.
21709 However, note that for some attributes you must check
21710 attr_form_is_section_offset before using this test. DW_FORM_data4
21711 and DW_FORM_data8 are members of both the constant class, and of
21712 the classes that contain offsets into other debug sections
21713 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21714 that, if an attribute's can be either a constant or one of the
21715 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21716 taken as section offsets, not constants. */
21719 attr_form_is_constant (const struct attribute
*attr
)
21721 switch (attr
->form
)
21723 case DW_FORM_sdata
:
21724 case DW_FORM_udata
:
21725 case DW_FORM_data1
:
21726 case DW_FORM_data2
:
21727 case DW_FORM_data4
:
21728 case DW_FORM_data8
:
21736 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21737 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21740 attr_form_is_ref (const struct attribute
*attr
)
21742 switch (attr
->form
)
21744 case DW_FORM_ref_addr
:
21749 case DW_FORM_ref_udata
:
21750 case DW_FORM_GNU_ref_alt
:
21757 /* Return the .debug_loc section to use for CU.
21758 For DWO files use .debug_loc.dwo. */
21760 static struct dwarf2_section_info
*
21761 cu_debug_loc_section (struct dwarf2_cu
*cu
)
21764 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
21765 return &dwarf2_per_objfile
->loc
;
21768 /* A helper function that fills in a dwarf2_loclist_baton. */
21771 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
21772 struct dwarf2_loclist_baton
*baton
,
21773 const struct attribute
*attr
)
21775 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21777 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
21779 baton
->per_cu
= cu
->per_cu
;
21780 gdb_assert (baton
->per_cu
);
21781 /* We don't know how long the location list is, but make sure we
21782 don't run off the edge of the section. */
21783 baton
->size
= section
->size
- DW_UNSND (attr
);
21784 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
21785 baton
->base_address
= cu
->base_address
;
21786 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
21790 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
21791 struct dwarf2_cu
*cu
, int is_block
)
21793 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21794 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21796 if (attr_form_is_section_offset (attr
)
21797 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21798 the section. If so, fall through to the complaint in the
21800 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
21802 struct dwarf2_loclist_baton
*baton
;
21804 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21805 sizeof (struct dwarf2_loclist_baton
));
21807 fill_in_loclist_baton (cu
, baton
, attr
);
21809 if (cu
->base_known
== 0)
21810 complaint (&symfile_complaints
,
21811 _("Location list used without "
21812 "specifying the CU base address."));
21814 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21815 ? dwarf2_loclist_block_index
21816 : dwarf2_loclist_index
);
21817 SYMBOL_LOCATION_BATON (sym
) = baton
;
21821 struct dwarf2_locexpr_baton
*baton
;
21823 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21824 sizeof (struct dwarf2_locexpr_baton
));
21825 baton
->per_cu
= cu
->per_cu
;
21826 gdb_assert (baton
->per_cu
);
21828 if (attr_form_is_block (attr
))
21830 /* Note that we're just copying the block's data pointer
21831 here, not the actual data. We're still pointing into the
21832 info_buffer for SYM's objfile; right now we never release
21833 that buffer, but when we do clean up properly this may
21835 baton
->size
= DW_BLOCK (attr
)->size
;
21836 baton
->data
= DW_BLOCK (attr
)->data
;
21840 dwarf2_invalid_attrib_class_complaint ("location description",
21841 SYMBOL_NATURAL_NAME (sym
));
21845 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21846 ? dwarf2_locexpr_block_index
21847 : dwarf2_locexpr_index
);
21848 SYMBOL_LOCATION_BATON (sym
) = baton
;
21852 /* Return the OBJFILE associated with the compilation unit CU. If CU
21853 came from a separate debuginfo file, then the master objfile is
21857 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
21859 struct objfile
*objfile
= per_cu
->objfile
;
21861 /* Return the master objfile, so that we can report and look up the
21862 correct file containing this variable. */
21863 if (objfile
->separate_debug_objfile_backlink
)
21864 objfile
= objfile
->separate_debug_objfile_backlink
;
21869 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21870 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21871 CU_HEADERP first. */
21873 static const struct comp_unit_head
*
21874 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
21875 struct dwarf2_per_cu_data
*per_cu
)
21877 const gdb_byte
*info_ptr
;
21880 return &per_cu
->cu
->header
;
21882 info_ptr
= per_cu
->section
->buffer
+ per_cu
->offset
.sect_off
;
21884 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
21885 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
21890 /* Return the address size given in the compilation unit header for CU. */
21893 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21895 struct comp_unit_head cu_header_local
;
21896 const struct comp_unit_head
*cu_headerp
;
21898 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21900 return cu_headerp
->addr_size
;
21903 /* Return the offset size given in the compilation unit header for CU. */
21906 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
21908 struct comp_unit_head cu_header_local
;
21909 const struct comp_unit_head
*cu_headerp
;
21911 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21913 return cu_headerp
->offset_size
;
21916 /* See its dwarf2loc.h declaration. */
21919 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21921 struct comp_unit_head cu_header_local
;
21922 const struct comp_unit_head
*cu_headerp
;
21924 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21926 if (cu_headerp
->version
== 2)
21927 return cu_headerp
->addr_size
;
21929 return cu_headerp
->offset_size
;
21932 /* Return the text offset of the CU. The returned offset comes from
21933 this CU's objfile. If this objfile came from a separate debuginfo
21934 file, then the offset may be different from the corresponding
21935 offset in the parent objfile. */
21938 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
21940 struct objfile
*objfile
= per_cu
->objfile
;
21942 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21945 /* Locate the .debug_info compilation unit from CU's objfile which contains
21946 the DIE at OFFSET. Raises an error on failure. */
21948 static struct dwarf2_per_cu_data
*
21949 dwarf2_find_containing_comp_unit (sect_offset offset
,
21950 unsigned int offset_in_dwz
,
21951 struct objfile
*objfile
)
21953 struct dwarf2_per_cu_data
*this_cu
;
21955 const sect_offset
*cu_off
;
21958 high
= dwarf2_per_objfile
->n_comp_units
- 1;
21961 struct dwarf2_per_cu_data
*mid_cu
;
21962 int mid
= low
+ (high
- low
) / 2;
21964 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
21965 cu_off
= &mid_cu
->offset
;
21966 if (mid_cu
->is_dwz
> offset_in_dwz
21967 || (mid_cu
->is_dwz
== offset_in_dwz
21968 && cu_off
->sect_off
>= offset
.sect_off
))
21973 gdb_assert (low
== high
);
21974 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
21975 cu_off
= &this_cu
->offset
;
21976 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
21978 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
21979 error (_("Dwarf Error: could not find partial DIE containing "
21980 "offset 0x%lx [in module %s]"),
21981 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
21983 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
21984 <= offset
.sect_off
);
21985 return dwarf2_per_objfile
->all_comp_units
[low
-1];
21989 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
21990 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
21991 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
21992 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
21993 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
21998 /* Initialize dwarf2_cu CU, owned by PER_CU. */
22001 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
22003 memset (cu
, 0, sizeof (*cu
));
22005 cu
->per_cu
= per_cu
;
22006 cu
->objfile
= per_cu
->objfile
;
22007 obstack_init (&cu
->comp_unit_obstack
);
22010 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
22013 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
22014 enum language pretend_language
)
22016 struct attribute
*attr
;
22018 /* Set the language we're debugging. */
22019 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
22021 set_cu_language (DW_UNSND (attr
), cu
);
22024 cu
->language
= pretend_language
;
22025 cu
->language_defn
= language_def (cu
->language
);
22028 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
22030 cu
->producer
= DW_STRING (attr
);
22033 /* Release one cached compilation unit, CU. We unlink it from the tree
22034 of compilation units, but we don't remove it from the read_in_chain;
22035 the caller is responsible for that.
22036 NOTE: DATA is a void * because this function is also used as a
22037 cleanup routine. */
22040 free_heap_comp_unit (void *data
)
22042 struct dwarf2_cu
*cu
= data
;
22044 gdb_assert (cu
->per_cu
!= NULL
);
22045 cu
->per_cu
->cu
= NULL
;
22048 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22053 /* This cleanup function is passed the address of a dwarf2_cu on the stack
22054 when we're finished with it. We can't free the pointer itself, but be
22055 sure to unlink it from the cache. Also release any associated storage. */
22058 free_stack_comp_unit (void *data
)
22060 struct dwarf2_cu
*cu
= data
;
22062 gdb_assert (cu
->per_cu
!= NULL
);
22063 cu
->per_cu
->cu
= NULL
;
22066 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22067 cu
->partial_dies
= NULL
;
22070 /* Free all cached compilation units. */
22073 free_cached_comp_units (void *data
)
22075 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22077 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22078 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22079 while (per_cu
!= NULL
)
22081 struct dwarf2_per_cu_data
*next_cu
;
22083 next_cu
= per_cu
->cu
->read_in_chain
;
22085 free_heap_comp_unit (per_cu
->cu
);
22086 *last_chain
= next_cu
;
22092 /* Increase the age counter on each cached compilation unit, and free
22093 any that are too old. */
22096 age_cached_comp_units (void)
22098 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22100 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
22101 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22102 while (per_cu
!= NULL
)
22104 per_cu
->cu
->last_used
++;
22105 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
22106 dwarf2_mark (per_cu
->cu
);
22107 per_cu
= per_cu
->cu
->read_in_chain
;
22110 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22111 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22112 while (per_cu
!= NULL
)
22114 struct dwarf2_per_cu_data
*next_cu
;
22116 next_cu
= per_cu
->cu
->read_in_chain
;
22118 if (!per_cu
->cu
->mark
)
22120 free_heap_comp_unit (per_cu
->cu
);
22121 *last_chain
= next_cu
;
22124 last_chain
= &per_cu
->cu
->read_in_chain
;
22130 /* Remove a single compilation unit from the cache. */
22133 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
22135 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22137 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22138 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22139 while (per_cu
!= NULL
)
22141 struct dwarf2_per_cu_data
*next_cu
;
22143 next_cu
= per_cu
->cu
->read_in_chain
;
22145 if (per_cu
== target_per_cu
)
22147 free_heap_comp_unit (per_cu
->cu
);
22149 *last_chain
= next_cu
;
22153 last_chain
= &per_cu
->cu
->read_in_chain
;
22159 /* Release all extra memory associated with OBJFILE. */
22162 dwarf2_free_objfile (struct objfile
*objfile
)
22164 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
22166 if (dwarf2_per_objfile
== NULL
)
22169 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
22170 free_cached_comp_units (NULL
);
22172 if (dwarf2_per_objfile
->quick_file_names_table
)
22173 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
22175 if (dwarf2_per_objfile
->line_header_hash
)
22176 htab_delete (dwarf2_per_objfile
->line_header_hash
);
22178 /* Everything else should be on the objfile obstack. */
22181 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
22182 We store these in a hash table separate from the DIEs, and preserve them
22183 when the DIEs are flushed out of cache.
22185 The CU "per_cu" pointer is needed because offset alone is not enough to
22186 uniquely identify the type. A file may have multiple .debug_types sections,
22187 or the type may come from a DWO file. Furthermore, while it's more logical
22188 to use per_cu->section+offset, with Fission the section with the data is in
22189 the DWO file but we don't know that section at the point we need it.
22190 We have to use something in dwarf2_per_cu_data (or the pointer to it)
22191 because we can enter the lookup routine, get_die_type_at_offset, from
22192 outside this file, and thus won't necessarily have PER_CU->cu.
22193 Fortunately, PER_CU is stable for the life of the objfile. */
22195 struct dwarf2_per_cu_offset_and_type
22197 const struct dwarf2_per_cu_data
*per_cu
;
22198 sect_offset offset
;
22202 /* Hash function for a dwarf2_per_cu_offset_and_type. */
22205 per_cu_offset_and_type_hash (const void *item
)
22207 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
22209 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
22212 /* Equality function for a dwarf2_per_cu_offset_and_type. */
22215 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
22217 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
22218 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
22220 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
22221 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
22224 /* Set the type associated with DIE to TYPE. Save it in CU's hash
22225 table if necessary. For convenience, return TYPE.
22227 The DIEs reading must have careful ordering to:
22228 * Not cause infite loops trying to read in DIEs as a prerequisite for
22229 reading current DIE.
22230 * Not trying to dereference contents of still incompletely read in types
22231 while reading in other DIEs.
22232 * Enable referencing still incompletely read in types just by a pointer to
22233 the type without accessing its fields.
22235 Therefore caller should follow these rules:
22236 * Try to fetch any prerequisite types we may need to build this DIE type
22237 before building the type and calling set_die_type.
22238 * After building type call set_die_type for current DIE as soon as
22239 possible before fetching more types to complete the current type.
22240 * Make the type as complete as possible before fetching more types. */
22242 static struct type
*
22243 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
22245 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
22246 struct objfile
*objfile
= cu
->objfile
;
22247 struct attribute
*attr
;
22248 struct dynamic_prop prop
;
22250 /* For Ada types, make sure that the gnat-specific data is always
22251 initialized (if not already set). There are a few types where
22252 we should not be doing so, because the type-specific area is
22253 already used to hold some other piece of info (eg: TYPE_CODE_FLT
22254 where the type-specific area is used to store the floatformat).
22255 But this is not a problem, because the gnat-specific information
22256 is actually not needed for these types. */
22257 if (need_gnat_info (cu
)
22258 && TYPE_CODE (type
) != TYPE_CODE_FUNC
22259 && TYPE_CODE (type
) != TYPE_CODE_FLT
22260 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
22261 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
22262 && TYPE_CODE (type
) != TYPE_CODE_METHOD
22263 && !HAVE_GNAT_AUX_INFO (type
))
22264 INIT_GNAT_SPECIFIC (type
);
22266 /* Read DW_AT_data_location and set in type. */
22267 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
22268 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
22269 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
, objfile
);
22271 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22273 dwarf2_per_objfile
->die_type_hash
=
22274 htab_create_alloc_ex (127,
22275 per_cu_offset_and_type_hash
,
22276 per_cu_offset_and_type_eq
,
22278 &objfile
->objfile_obstack
,
22279 hashtab_obstack_allocate
,
22280 dummy_obstack_deallocate
);
22283 ofs
.per_cu
= cu
->per_cu
;
22284 ofs
.offset
= die
->offset
;
22286 slot
= (struct dwarf2_per_cu_offset_and_type
**)
22287 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
22289 complaint (&symfile_complaints
,
22290 _("A problem internal to GDB: DIE 0x%x has type already set"),
22291 die
->offset
.sect_off
);
22292 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
22297 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
22298 or return NULL if the die does not have a saved type. */
22300 static struct type
*
22301 get_die_type_at_offset (sect_offset offset
,
22302 struct dwarf2_per_cu_data
*per_cu
)
22304 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
22306 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22309 ofs
.per_cu
= per_cu
;
22310 ofs
.offset
= offset
;
22311 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
22318 /* Look up the type for DIE in CU in die_type_hash,
22319 or return NULL if DIE does not have a saved type. */
22321 static struct type
*
22322 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22324 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
22327 /* Add a dependence relationship from CU to REF_PER_CU. */
22330 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
22331 struct dwarf2_per_cu_data
*ref_per_cu
)
22335 if (cu
->dependencies
== NULL
)
22337 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
22338 NULL
, &cu
->comp_unit_obstack
,
22339 hashtab_obstack_allocate
,
22340 dummy_obstack_deallocate
);
22342 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
22344 *slot
= ref_per_cu
;
22347 /* Subroutine of dwarf2_mark to pass to htab_traverse.
22348 Set the mark field in every compilation unit in the
22349 cache that we must keep because we are keeping CU. */
22352 dwarf2_mark_helper (void **slot
, void *data
)
22354 struct dwarf2_per_cu_data
*per_cu
;
22356 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
22358 /* cu->dependencies references may not yet have been ever read if QUIT aborts
22359 reading of the chain. As such dependencies remain valid it is not much
22360 useful to track and undo them during QUIT cleanups. */
22361 if (per_cu
->cu
== NULL
)
22364 if (per_cu
->cu
->mark
)
22366 per_cu
->cu
->mark
= 1;
22368 if (per_cu
->cu
->dependencies
!= NULL
)
22369 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22374 /* Set the mark field in CU and in every other compilation unit in the
22375 cache that we must keep because we are keeping CU. */
22378 dwarf2_mark (struct dwarf2_cu
*cu
)
22383 if (cu
->dependencies
!= NULL
)
22384 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22388 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
22392 per_cu
->cu
->mark
= 0;
22393 per_cu
= per_cu
->cu
->read_in_chain
;
22397 /* Trivial hash function for partial_die_info: the hash value of a DIE
22398 is its offset in .debug_info for this objfile. */
22401 partial_die_hash (const void *item
)
22403 const struct partial_die_info
*part_die
= item
;
22405 return part_die
->offset
.sect_off
;
22408 /* Trivial comparison function for partial_die_info structures: two DIEs
22409 are equal if they have the same offset. */
22412 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
22414 const struct partial_die_info
*part_die_lhs
= item_lhs
;
22415 const struct partial_die_info
*part_die_rhs
= item_rhs
;
22417 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
22420 static struct cmd_list_element
*set_dwarf_cmdlist
;
22421 static struct cmd_list_element
*show_dwarf_cmdlist
;
22424 set_dwarf_cmd (char *args
, int from_tty
)
22426 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
22431 show_dwarf_cmd (char *args
, int from_tty
)
22433 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
22436 /* Free data associated with OBJFILE, if necessary. */
22439 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
22441 struct dwarf2_per_objfile
*data
= d
;
22444 /* Make sure we don't accidentally use dwarf2_per_objfile while
22446 dwarf2_per_objfile
= NULL
;
22448 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
22449 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
22451 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
22452 VEC_free (dwarf2_per_cu_ptr
,
22453 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
22454 xfree (data
->all_type_units
);
22456 VEC_free (dwarf2_section_info_def
, data
->types
);
22458 if (data
->dwo_files
)
22459 free_dwo_files (data
->dwo_files
, objfile
);
22460 if (data
->dwp_file
)
22461 gdb_bfd_unref (data
->dwp_file
->dbfd
);
22463 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
22464 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
22468 /* The "save gdb-index" command. */
22470 /* The contents of the hash table we create when building the string
22472 struct strtab_entry
22474 offset_type offset
;
22478 /* Hash function for a strtab_entry.
22480 Function is used only during write_hash_table so no index format backward
22481 compatibility is needed. */
22484 hash_strtab_entry (const void *e
)
22486 const struct strtab_entry
*entry
= e
;
22487 return mapped_index_string_hash (INT_MAX
, entry
->str
);
22490 /* Equality function for a strtab_entry. */
22493 eq_strtab_entry (const void *a
, const void *b
)
22495 const struct strtab_entry
*ea
= a
;
22496 const struct strtab_entry
*eb
= b
;
22497 return !strcmp (ea
->str
, eb
->str
);
22500 /* Create a strtab_entry hash table. */
22503 create_strtab (void)
22505 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
22506 xfree
, xcalloc
, xfree
);
22509 /* Add a string to the constant pool. Return the string's offset in
22513 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
22516 struct strtab_entry entry
;
22517 struct strtab_entry
*result
;
22520 slot
= htab_find_slot (table
, &entry
, INSERT
);
22525 result
= XNEW (struct strtab_entry
);
22526 result
->offset
= obstack_object_size (cpool
);
22528 obstack_grow_str0 (cpool
, str
);
22531 return result
->offset
;
22534 /* An entry in the symbol table. */
22535 struct symtab_index_entry
22537 /* The name of the symbol. */
22539 /* The offset of the name in the constant pool. */
22540 offset_type index_offset
;
22541 /* A sorted vector of the indices of all the CUs that hold an object
22543 VEC (offset_type
) *cu_indices
;
22546 /* The symbol table. This is a power-of-2-sized hash table. */
22547 struct mapped_symtab
22549 offset_type n_elements
;
22551 struct symtab_index_entry
**data
;
22554 /* Hash function for a symtab_index_entry. */
22557 hash_symtab_entry (const void *e
)
22559 const struct symtab_index_entry
*entry
= e
;
22560 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
22561 sizeof (offset_type
) * VEC_length (offset_type
,
22562 entry
->cu_indices
),
22566 /* Equality function for a symtab_index_entry. */
22569 eq_symtab_entry (const void *a
, const void *b
)
22571 const struct symtab_index_entry
*ea
= a
;
22572 const struct symtab_index_entry
*eb
= b
;
22573 int len
= VEC_length (offset_type
, ea
->cu_indices
);
22574 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
22576 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
22577 VEC_address (offset_type
, eb
->cu_indices
),
22578 sizeof (offset_type
) * len
);
22581 /* Destroy a symtab_index_entry. */
22584 delete_symtab_entry (void *p
)
22586 struct symtab_index_entry
*entry
= p
;
22587 VEC_free (offset_type
, entry
->cu_indices
);
22591 /* Create a hash table holding symtab_index_entry objects. */
22594 create_symbol_hash_table (void)
22596 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
22597 delete_symtab_entry
, xcalloc
, xfree
);
22600 /* Create a new mapped symtab object. */
22602 static struct mapped_symtab
*
22603 create_mapped_symtab (void)
22605 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
22606 symtab
->n_elements
= 0;
22607 symtab
->size
= 1024;
22608 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22612 /* Destroy a mapped_symtab. */
22615 cleanup_mapped_symtab (void *p
)
22617 struct mapped_symtab
*symtab
= p
;
22618 /* The contents of the array are freed when the other hash table is
22620 xfree (symtab
->data
);
22624 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22627 Function is used only during write_hash_table so no index format backward
22628 compatibility is needed. */
22630 static struct symtab_index_entry
**
22631 find_slot (struct mapped_symtab
*symtab
, const char *name
)
22633 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
22635 index
= hash
& (symtab
->size
- 1);
22636 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
22640 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
22641 return &symtab
->data
[index
];
22642 index
= (index
+ step
) & (symtab
->size
- 1);
22646 /* Expand SYMTAB's hash table. */
22649 hash_expand (struct mapped_symtab
*symtab
)
22651 offset_type old_size
= symtab
->size
;
22653 struct symtab_index_entry
**old_entries
= symtab
->data
;
22656 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22658 for (i
= 0; i
< old_size
; ++i
)
22660 if (old_entries
[i
])
22662 struct symtab_index_entry
**slot
= find_slot (symtab
,
22663 old_entries
[i
]->name
);
22664 *slot
= old_entries
[i
];
22668 xfree (old_entries
);
22671 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22672 CU_INDEX is the index of the CU in which the symbol appears.
22673 IS_STATIC is one if the symbol is static, otherwise zero (global). */
22676 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
22677 int is_static
, gdb_index_symbol_kind kind
,
22678 offset_type cu_index
)
22680 struct symtab_index_entry
**slot
;
22681 offset_type cu_index_and_attrs
;
22683 ++symtab
->n_elements
;
22684 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
22685 hash_expand (symtab
);
22687 slot
= find_slot (symtab
, name
);
22690 *slot
= XNEW (struct symtab_index_entry
);
22691 (*slot
)->name
= name
;
22692 /* index_offset is set later. */
22693 (*slot
)->cu_indices
= NULL
;
22696 cu_index_and_attrs
= 0;
22697 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
22698 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
22699 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
22701 /* We don't want to record an index value twice as we want to avoid the
22703 We process all global symbols and then all static symbols
22704 (which would allow us to avoid the duplication by only having to check
22705 the last entry pushed), but a symbol could have multiple kinds in one CU.
22706 To keep things simple we don't worry about the duplication here and
22707 sort and uniqufy the list after we've processed all symbols. */
22708 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
22711 /* qsort helper routine for uniquify_cu_indices. */
22714 offset_type_compare (const void *ap
, const void *bp
)
22716 offset_type a
= *(offset_type
*) ap
;
22717 offset_type b
= *(offset_type
*) bp
;
22719 return (a
> b
) - (b
> a
);
22722 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22725 uniquify_cu_indices (struct mapped_symtab
*symtab
)
22729 for (i
= 0; i
< symtab
->size
; ++i
)
22731 struct symtab_index_entry
*entry
= symtab
->data
[i
];
22734 && entry
->cu_indices
!= NULL
)
22736 unsigned int next_to_insert
, next_to_check
;
22737 offset_type last_value
;
22739 qsort (VEC_address (offset_type
, entry
->cu_indices
),
22740 VEC_length (offset_type
, entry
->cu_indices
),
22741 sizeof (offset_type
), offset_type_compare
);
22743 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
22744 next_to_insert
= 1;
22745 for (next_to_check
= 1;
22746 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
22749 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
22752 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
22754 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
22759 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
22764 /* Add a vector of indices to the constant pool. */
22767 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
22768 struct symtab_index_entry
*entry
)
22772 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
22775 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
22776 offset_type val
= MAYBE_SWAP (len
);
22781 entry
->index_offset
= obstack_object_size (cpool
);
22783 obstack_grow (cpool
, &val
, sizeof (val
));
22785 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
22788 val
= MAYBE_SWAP (iter
);
22789 obstack_grow (cpool
, &val
, sizeof (val
));
22794 struct symtab_index_entry
*old_entry
= *slot
;
22795 entry
->index_offset
= old_entry
->index_offset
;
22798 return entry
->index_offset
;
22801 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22802 constant pool entries going into the obstack CPOOL. */
22805 write_hash_table (struct mapped_symtab
*symtab
,
22806 struct obstack
*output
, struct obstack
*cpool
)
22809 htab_t symbol_hash_table
;
22812 symbol_hash_table
= create_symbol_hash_table ();
22813 str_table
= create_strtab ();
22815 /* We add all the index vectors to the constant pool first, to
22816 ensure alignment is ok. */
22817 for (i
= 0; i
< symtab
->size
; ++i
)
22819 if (symtab
->data
[i
])
22820 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
22823 /* Now write out the hash table. */
22824 for (i
= 0; i
< symtab
->size
; ++i
)
22826 offset_type str_off
, vec_off
;
22828 if (symtab
->data
[i
])
22830 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
22831 vec_off
= symtab
->data
[i
]->index_offset
;
22835 /* While 0 is a valid constant pool index, it is not valid
22836 to have 0 for both offsets. */
22841 str_off
= MAYBE_SWAP (str_off
);
22842 vec_off
= MAYBE_SWAP (vec_off
);
22844 obstack_grow (output
, &str_off
, sizeof (str_off
));
22845 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
22848 htab_delete (str_table
);
22849 htab_delete (symbol_hash_table
);
22852 /* Struct to map psymtab to CU index in the index file. */
22853 struct psymtab_cu_index_map
22855 struct partial_symtab
*psymtab
;
22856 unsigned int cu_index
;
22860 hash_psymtab_cu_index (const void *item
)
22862 const struct psymtab_cu_index_map
*map
= item
;
22864 return htab_hash_pointer (map
->psymtab
);
22868 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
22870 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
22871 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
22873 return lhs
->psymtab
== rhs
->psymtab
;
22876 /* Helper struct for building the address table. */
22877 struct addrmap_index_data
22879 struct objfile
*objfile
;
22880 struct obstack
*addr_obstack
;
22881 htab_t cu_index_htab
;
22883 /* Non-zero if the previous_* fields are valid.
22884 We can't write an entry until we see the next entry (since it is only then
22885 that we know the end of the entry). */
22886 int previous_valid
;
22887 /* Index of the CU in the table of all CUs in the index file. */
22888 unsigned int previous_cu_index
;
22889 /* Start address of the CU. */
22890 CORE_ADDR previous_cu_start
;
22893 /* Write an address entry to OBSTACK. */
22896 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
22897 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
22899 offset_type cu_index_to_write
;
22901 CORE_ADDR baseaddr
;
22903 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
22905 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
22906 obstack_grow (obstack
, addr
, 8);
22907 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
22908 obstack_grow (obstack
, addr
, 8);
22909 cu_index_to_write
= MAYBE_SWAP (cu_index
);
22910 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
22913 /* Worker function for traversing an addrmap to build the address table. */
22916 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
22918 struct addrmap_index_data
*data
= datap
;
22919 struct partial_symtab
*pst
= obj
;
22921 if (data
->previous_valid
)
22922 add_address_entry (data
->objfile
, data
->addr_obstack
,
22923 data
->previous_cu_start
, start_addr
,
22924 data
->previous_cu_index
);
22926 data
->previous_cu_start
= start_addr
;
22929 struct psymtab_cu_index_map find_map
, *map
;
22930 find_map
.psymtab
= pst
;
22931 map
= htab_find (data
->cu_index_htab
, &find_map
);
22932 gdb_assert (map
!= NULL
);
22933 data
->previous_cu_index
= map
->cu_index
;
22934 data
->previous_valid
= 1;
22937 data
->previous_valid
= 0;
22942 /* Write OBJFILE's address map to OBSTACK.
22943 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22944 in the index file. */
22947 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
22948 htab_t cu_index_htab
)
22950 struct addrmap_index_data addrmap_index_data
;
22952 /* When writing the address table, we have to cope with the fact that
22953 the addrmap iterator only provides the start of a region; we have to
22954 wait until the next invocation to get the start of the next region. */
22956 addrmap_index_data
.objfile
= objfile
;
22957 addrmap_index_data
.addr_obstack
= obstack
;
22958 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
22959 addrmap_index_data
.previous_valid
= 0;
22961 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
22962 &addrmap_index_data
);
22964 /* It's highly unlikely the last entry (end address = 0xff...ff)
22965 is valid, but we should still handle it.
22966 The end address is recorded as the start of the next region, but that
22967 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22969 if (addrmap_index_data
.previous_valid
)
22970 add_address_entry (objfile
, obstack
,
22971 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
22972 addrmap_index_data
.previous_cu_index
);
22975 /* Return the symbol kind of PSYM. */
22977 static gdb_index_symbol_kind
22978 symbol_kind (struct partial_symbol
*psym
)
22980 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
22981 enum address_class aclass
= PSYMBOL_CLASS (psym
);
22989 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
22991 return GDB_INDEX_SYMBOL_KIND_TYPE
;
22993 case LOC_CONST_BYTES
:
22994 case LOC_OPTIMIZED_OUT
:
22996 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
22998 /* Note: It's currently impossible to recognize psyms as enum values
22999 short of reading the type info. For now punt. */
23000 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
23002 /* There are other LOC_FOO values that one might want to classify
23003 as variables, but dwarf2read.c doesn't currently use them. */
23004 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23006 case STRUCT_DOMAIN
:
23007 return GDB_INDEX_SYMBOL_KIND_TYPE
;
23009 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23013 /* Add a list of partial symbols to SYMTAB. */
23016 write_psymbols (struct mapped_symtab
*symtab
,
23018 struct partial_symbol
**psymp
,
23020 offset_type cu_index
,
23023 for (; count
-- > 0; ++psymp
)
23025 struct partial_symbol
*psym
= *psymp
;
23028 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
23029 error (_("Ada is not currently supported by the index"));
23031 /* Only add a given psymbol once. */
23032 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
23035 gdb_index_symbol_kind kind
= symbol_kind (psym
);
23038 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
23039 is_static
, kind
, cu_index
);
23044 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
23045 exception if there is an error. */
23048 write_obstack (FILE *file
, struct obstack
*obstack
)
23050 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
23052 != obstack_object_size (obstack
))
23053 error (_("couldn't data write to file"));
23056 /* Unlink a file if the argument is not NULL. */
23059 unlink_if_set (void *p
)
23061 char **filename
= p
;
23063 unlink (*filename
);
23066 /* A helper struct used when iterating over debug_types. */
23067 struct signatured_type_index_data
23069 struct objfile
*objfile
;
23070 struct mapped_symtab
*symtab
;
23071 struct obstack
*types_list
;
23076 /* A helper function that writes a single signatured_type to an
23080 write_one_signatured_type (void **slot
, void *d
)
23082 struct signatured_type_index_data
*info
= d
;
23083 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
23084 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
23087 write_psymbols (info
->symtab
,
23089 info
->objfile
->global_psymbols
.list
23090 + psymtab
->globals_offset
,
23091 psymtab
->n_global_syms
, info
->cu_index
,
23093 write_psymbols (info
->symtab
,
23095 info
->objfile
->static_psymbols
.list
23096 + psymtab
->statics_offset
,
23097 psymtab
->n_static_syms
, info
->cu_index
,
23100 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23101 entry
->per_cu
.offset
.sect_off
);
23102 obstack_grow (info
->types_list
, val
, 8);
23103 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23104 entry
->type_offset_in_tu
.cu_off
);
23105 obstack_grow (info
->types_list
, val
, 8);
23106 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
23107 obstack_grow (info
->types_list
, val
, 8);
23114 /* Recurse into all "included" dependencies and write their symbols as
23115 if they appeared in this psymtab. */
23118 recursively_write_psymbols (struct objfile
*objfile
,
23119 struct partial_symtab
*psymtab
,
23120 struct mapped_symtab
*symtab
,
23122 offset_type cu_index
)
23126 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
23127 if (psymtab
->dependencies
[i
]->user
!= NULL
)
23128 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
23129 symtab
, psyms_seen
, cu_index
);
23131 write_psymbols (symtab
,
23133 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
23134 psymtab
->n_global_syms
, cu_index
,
23136 write_psymbols (symtab
,
23138 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
23139 psymtab
->n_static_syms
, cu_index
,
23143 /* Create an index file for OBJFILE in the directory DIR. */
23146 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
23148 struct cleanup
*cleanup
;
23149 char *filename
, *cleanup_filename
;
23150 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
23151 struct obstack cu_list
, types_cu_list
;
23154 struct mapped_symtab
*symtab
;
23155 offset_type val
, size_of_contents
, total_len
;
23158 htab_t cu_index_htab
;
23159 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
23161 if (dwarf2_per_objfile
->using_index
)
23162 error (_("Cannot use an index to create the index"));
23164 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
23165 error (_("Cannot make an index when the file has multiple .debug_types sections"));
23167 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
23170 if (stat (objfile_name (objfile
), &st
) < 0)
23171 perror_with_name (objfile_name (objfile
));
23173 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile_name (objfile
)),
23174 INDEX_SUFFIX
, (char *) NULL
);
23175 cleanup
= make_cleanup (xfree
, filename
);
23177 out_file
= gdb_fopen_cloexec (filename
, "wb");
23179 error (_("Can't open `%s' for writing"), filename
);
23181 cleanup_filename
= filename
;
23182 make_cleanup (unlink_if_set
, &cleanup_filename
);
23184 symtab
= create_mapped_symtab ();
23185 make_cleanup (cleanup_mapped_symtab
, symtab
);
23187 obstack_init (&addr_obstack
);
23188 make_cleanup_obstack_free (&addr_obstack
);
23190 obstack_init (&cu_list
);
23191 make_cleanup_obstack_free (&cu_list
);
23193 obstack_init (&types_cu_list
);
23194 make_cleanup_obstack_free (&types_cu_list
);
23196 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
23197 NULL
, xcalloc
, xfree
);
23198 make_cleanup_htab_delete (psyms_seen
);
23200 /* While we're scanning CU's create a table that maps a psymtab pointer
23201 (which is what addrmap records) to its index (which is what is recorded
23202 in the index file). This will later be needed to write the address
23204 cu_index_htab
= htab_create_alloc (100,
23205 hash_psymtab_cu_index
,
23206 eq_psymtab_cu_index
,
23207 NULL
, xcalloc
, xfree
);
23208 make_cleanup_htab_delete (cu_index_htab
);
23209 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
23210 xmalloc (sizeof (struct psymtab_cu_index_map
)
23211 * dwarf2_per_objfile
->n_comp_units
);
23212 make_cleanup (xfree
, psymtab_cu_index_map
);
23214 /* The CU list is already sorted, so we don't need to do additional
23215 work here. Also, the debug_types entries do not appear in
23216 all_comp_units, but only in their own hash table. */
23217 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
23219 struct dwarf2_per_cu_data
*per_cu
23220 = dwarf2_per_objfile
->all_comp_units
[i
];
23221 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
23223 struct psymtab_cu_index_map
*map
;
23226 /* CU of a shared file from 'dwz -m' may be unused by this main file.
23227 It may be referenced from a local scope but in such case it does not
23228 need to be present in .gdb_index. */
23229 if (psymtab
== NULL
)
23232 if (psymtab
->user
== NULL
)
23233 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
23235 map
= &psymtab_cu_index_map
[i
];
23236 map
->psymtab
= psymtab
;
23238 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
23239 gdb_assert (slot
!= NULL
);
23240 gdb_assert (*slot
== NULL
);
23243 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23244 per_cu
->offset
.sect_off
);
23245 obstack_grow (&cu_list
, val
, 8);
23246 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
23247 obstack_grow (&cu_list
, val
, 8);
23250 /* Dump the address map. */
23251 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
23253 /* Write out the .debug_type entries, if any. */
23254 if (dwarf2_per_objfile
->signatured_types
)
23256 struct signatured_type_index_data sig_data
;
23258 sig_data
.objfile
= objfile
;
23259 sig_data
.symtab
= symtab
;
23260 sig_data
.types_list
= &types_cu_list
;
23261 sig_data
.psyms_seen
= psyms_seen
;
23262 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
23263 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
23264 write_one_signatured_type
, &sig_data
);
23267 /* Now that we've processed all symbols we can shrink their cu_indices
23269 uniquify_cu_indices (symtab
);
23271 obstack_init (&constant_pool
);
23272 make_cleanup_obstack_free (&constant_pool
);
23273 obstack_init (&symtab_obstack
);
23274 make_cleanup_obstack_free (&symtab_obstack
);
23275 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
23277 obstack_init (&contents
);
23278 make_cleanup_obstack_free (&contents
);
23279 size_of_contents
= 6 * sizeof (offset_type
);
23280 total_len
= size_of_contents
;
23282 /* The version number. */
23283 val
= MAYBE_SWAP (8);
23284 obstack_grow (&contents
, &val
, sizeof (val
));
23286 /* The offset of the CU list from the start of the file. */
23287 val
= MAYBE_SWAP (total_len
);
23288 obstack_grow (&contents
, &val
, sizeof (val
));
23289 total_len
+= obstack_object_size (&cu_list
);
23291 /* The offset of the types CU list from the start of the file. */
23292 val
= MAYBE_SWAP (total_len
);
23293 obstack_grow (&contents
, &val
, sizeof (val
));
23294 total_len
+= obstack_object_size (&types_cu_list
);
23296 /* The offset of the address table from the start of the file. */
23297 val
= MAYBE_SWAP (total_len
);
23298 obstack_grow (&contents
, &val
, sizeof (val
));
23299 total_len
+= obstack_object_size (&addr_obstack
);
23301 /* The offset of the symbol table from the start of the file. */
23302 val
= MAYBE_SWAP (total_len
);
23303 obstack_grow (&contents
, &val
, sizeof (val
));
23304 total_len
+= obstack_object_size (&symtab_obstack
);
23306 /* The offset of the constant pool from the start of the file. */
23307 val
= MAYBE_SWAP (total_len
);
23308 obstack_grow (&contents
, &val
, sizeof (val
));
23309 total_len
+= obstack_object_size (&constant_pool
);
23311 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
23313 write_obstack (out_file
, &contents
);
23314 write_obstack (out_file
, &cu_list
);
23315 write_obstack (out_file
, &types_cu_list
);
23316 write_obstack (out_file
, &addr_obstack
);
23317 write_obstack (out_file
, &symtab_obstack
);
23318 write_obstack (out_file
, &constant_pool
);
23322 /* We want to keep the file, so we set cleanup_filename to NULL
23323 here. See unlink_if_set. */
23324 cleanup_filename
= NULL
;
23326 do_cleanups (cleanup
);
23329 /* Implementation of the `save gdb-index' command.
23331 Note that the file format used by this command is documented in the
23332 GDB manual. Any changes here must be documented there. */
23335 save_gdb_index_command (char *arg
, int from_tty
)
23337 struct objfile
*objfile
;
23340 error (_("usage: save gdb-index DIRECTORY"));
23342 ALL_OBJFILES (objfile
)
23346 /* If the objfile does not correspond to an actual file, skip it. */
23347 if (stat (objfile_name (objfile
), &st
) < 0)
23350 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
23351 if (dwarf2_per_objfile
)
23356 write_psymtabs_to_index (objfile
, arg
);
23358 CATCH (except
, RETURN_MASK_ERROR
)
23360 exception_fprintf (gdb_stderr
, except
,
23361 _("Error while writing index for `%s': "),
23362 objfile_name (objfile
));
23371 int dwarf_always_disassemble
;
23374 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
23375 struct cmd_list_element
*c
, const char *value
)
23377 fprintf_filtered (file
,
23378 _("Whether to always disassemble "
23379 "DWARF expressions is %s.\n"),
23384 show_check_physname (struct ui_file
*file
, int from_tty
,
23385 struct cmd_list_element
*c
, const char *value
)
23387 fprintf_filtered (file
,
23388 _("Whether to check \"physname\" is %s.\n"),
23392 void _initialize_dwarf2_read (void);
23395 _initialize_dwarf2_read (void)
23397 struct cmd_list_element
*c
;
23399 dwarf2_objfile_data_key
23400 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
23402 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
23403 Set DWARF specific variables.\n\
23404 Configure DWARF variables such as the cache size"),
23405 &set_dwarf_cmdlist
, "maintenance set dwarf ",
23406 0/*allow-unknown*/, &maintenance_set_cmdlist
);
23408 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
23409 Show DWARF specific variables\n\
23410 Show DWARF variables such as the cache size"),
23411 &show_dwarf_cmdlist
, "maintenance show dwarf ",
23412 0/*allow-unknown*/, &maintenance_show_cmdlist
);
23414 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
23415 &dwarf_max_cache_age
, _("\
23416 Set the upper bound on the age of cached DWARF compilation units."), _("\
23417 Show the upper bound on the age of cached DWARF compilation units."), _("\
23418 A higher limit means that cached compilation units will be stored\n\
23419 in memory longer, and more total memory will be used. Zero disables\n\
23420 caching, which can slow down startup."),
23422 show_dwarf_max_cache_age
,
23423 &set_dwarf_cmdlist
,
23424 &show_dwarf_cmdlist
);
23426 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
23427 &dwarf_always_disassemble
, _("\
23428 Set whether `info address' always disassembles DWARF expressions."), _("\
23429 Show whether `info address' always disassembles DWARF expressions."), _("\
23430 When enabled, DWARF expressions are always printed in an assembly-like\n\
23431 syntax. When disabled, expressions will be printed in a more\n\
23432 conversational style, when possible."),
23434 show_dwarf_always_disassemble
,
23435 &set_dwarf_cmdlist
,
23436 &show_dwarf_cmdlist
);
23438 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
23439 Set debugging of the DWARF reader."), _("\
23440 Show debugging of the DWARF reader."), _("\
23441 When enabled (non-zero), debugging messages are printed during DWARF\n\
23442 reading and symtab expansion. A value of 1 (one) provides basic\n\
23443 information. A value greater than 1 provides more verbose information."),
23446 &setdebuglist
, &showdebuglist
);
23448 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
23449 Set debugging of the DWARF DIE reader."), _("\
23450 Show debugging of the DWARF DIE reader."), _("\
23451 When enabled (non-zero), DIEs are dumped after they are read in.\n\
23452 The value is the maximum depth to print."),
23455 &setdebuglist
, &showdebuglist
);
23457 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
23458 Set debugging of the dwarf line reader."), _("\
23459 Show debugging of the dwarf line reader."), _("\
23460 When enabled (non-zero), line number entries are dumped as they are read in.\n\
23461 A value of 1 (one) provides basic information.\n\
23462 A value greater than 1 provides more verbose information."),
23465 &setdebuglist
, &showdebuglist
);
23467 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
23468 Set cross-checking of \"physname\" code against demangler."), _("\
23469 Show cross-checking of \"physname\" code against demangler."), _("\
23470 When enabled, GDB's internal \"physname\" code is checked against\n\
23472 NULL
, show_check_physname
,
23473 &setdebuglist
, &showdebuglist
);
23475 add_setshow_boolean_cmd ("use-deprecated-index-sections",
23476 no_class
, &use_deprecated_index_sections
, _("\
23477 Set whether to use deprecated gdb_index sections."), _("\
23478 Show whether to use deprecated gdb_index sections."), _("\
23479 When enabled, deprecated .gdb_index sections are used anyway.\n\
23480 Normally they are ignored either because of a missing feature or\n\
23481 performance issue.\n\
23482 Warning: This option must be enabled before gdb reads the file."),
23485 &setlist
, &showlist
);
23487 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
23489 Save a gdb-index file.\n\
23490 Usage: save gdb-index DIRECTORY"),
23492 set_cmd_completer (c
, filename_completer
);
23494 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23495 &dwarf2_locexpr_funcs
);
23496 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23497 &dwarf2_loclist_funcs
);
23499 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23500 &dwarf2_block_frame_base_locexpr_funcs
);
23501 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23502 &dwarf2_block_frame_base_loclist_funcs
);