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. This is left as NULL for
614 dummy CUs (a CU header, but nothing else). */
615 struct dwarf2_cu
*cu
;
617 /* The corresponding objfile.
618 Normally we can get the objfile from dwarf2_per_objfile.
619 However we can enter this file with just a "per_cu" handle. */
620 struct objfile
*objfile
;
622 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
623 is active. Otherwise, the 'psymtab' field is active. */
626 /* The partial symbol table associated with this compilation unit,
627 or NULL for unread partial units. */
628 struct partial_symtab
*psymtab
;
630 /* Data needed by the "quick" functions. */
631 struct dwarf2_per_cu_quick_data
*quick
;
634 /* The CUs we import using DW_TAG_imported_unit. This is filled in
635 while reading psymtabs, used to compute the psymtab dependencies,
636 and then cleared. Then it is filled in again while reading full
637 symbols, and only deleted when the objfile is destroyed.
639 This is also used to work around a difference between the way gold
640 generates .gdb_index version <=7 and the way gdb does. Arguably this
641 is a gold bug. For symbols coming from TUs, gold records in the index
642 the CU that includes the TU instead of the TU itself. This breaks
643 dw2_lookup_symbol: It assumes that if the index says symbol X lives
644 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
645 will find X. Alas TUs live in their own symtab, so after expanding CU Y
646 we need to look in TU Z to find X. Fortunately, this is akin to
647 DW_TAG_imported_unit, so we just use the same mechanism: For
648 .gdb_index version <=7 this also records the TUs that the CU referred
649 to. Concurrently with this change gdb was modified to emit version 8
650 indices so we only pay a price for gold generated indices.
651 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
652 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
655 /* Entry in the signatured_types hash table. */
657 struct signatured_type
659 /* The "per_cu" object of this type.
660 This struct is used iff per_cu.is_debug_types.
661 N.B.: This is the first member so that it's easy to convert pointers
663 struct dwarf2_per_cu_data per_cu
;
665 /* The type's signature. */
668 /* Offset in the TU of the type's DIE, as read from the TU header.
669 If this TU is a DWO stub and the definition lives in a DWO file
670 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
671 cu_offset type_offset_in_tu
;
673 /* Offset in the section of the type's DIE.
674 If the definition lives in a DWO file, this is the offset in the
675 .debug_types.dwo section.
676 The value is zero until the actual value is known.
677 Zero is otherwise not a valid section offset. */
678 sect_offset type_offset_in_section
;
680 /* Type units are grouped by their DW_AT_stmt_list entry so that they
681 can share them. This points to the containing symtab. */
682 struct type_unit_group
*type_unit_group
;
685 The first time we encounter this type we fully read it in and install it
686 in the symbol tables. Subsequent times we only need the type. */
689 /* Containing DWO unit.
690 This field is valid iff per_cu.reading_dwo_directly. */
691 struct dwo_unit
*dwo_unit
;
694 typedef struct signatured_type
*sig_type_ptr
;
695 DEF_VEC_P (sig_type_ptr
);
697 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
698 This includes type_unit_group and quick_file_names. */
700 struct stmt_list_hash
702 /* The DWO unit this table is from or NULL if there is none. */
703 struct dwo_unit
*dwo_unit
;
705 /* Offset in .debug_line or .debug_line.dwo. */
706 sect_offset line_offset
;
709 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
710 an object of this type. */
712 struct type_unit_group
714 /* dwarf2read.c's main "handle" on a TU symtab.
715 To simplify things we create an artificial CU that "includes" all the
716 type units using this stmt_list so that the rest of the code still has
717 a "per_cu" handle on the symtab.
718 This PER_CU is recognized by having no section. */
719 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
720 struct dwarf2_per_cu_data per_cu
;
722 /* The TUs that share this DW_AT_stmt_list entry.
723 This is added to while parsing type units to build partial symtabs,
724 and is deleted afterwards and not used again. */
725 VEC (sig_type_ptr
) *tus
;
727 /* The compunit symtab.
728 Type units in a group needn't all be defined in the same source file,
729 so we create an essentially anonymous symtab as the compunit symtab. */
730 struct compunit_symtab
*compunit_symtab
;
732 /* The data used to construct the hash key. */
733 struct stmt_list_hash hash
;
735 /* The number of symtabs from the line header.
736 The value here must match line_header.num_file_names. */
737 unsigned int num_symtabs
;
739 /* The symbol tables for this TU (obtained from the files listed in
741 WARNING: The order of entries here must match the order of entries
742 in the line header. After the first TU using this type_unit_group, the
743 line header for the subsequent TUs is recreated from this. This is done
744 because we need to use the same symtabs for each TU using the same
745 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
746 there's no guarantee the line header doesn't have duplicate entries. */
747 struct symtab
**symtabs
;
750 /* These sections are what may appear in a (real or virtual) DWO file. */
754 struct dwarf2_section_info abbrev
;
755 struct dwarf2_section_info line
;
756 struct dwarf2_section_info loc
;
757 struct dwarf2_section_info macinfo
;
758 struct dwarf2_section_info macro
;
759 struct dwarf2_section_info str
;
760 struct dwarf2_section_info str_offsets
;
761 /* In the case of a virtual DWO file, these two are unused. */
762 struct dwarf2_section_info info
;
763 VEC (dwarf2_section_info_def
) *types
;
766 /* CUs/TUs in DWP/DWO files. */
770 /* Backlink to the containing struct dwo_file. */
771 struct dwo_file
*dwo_file
;
773 /* The "id" that distinguishes this CU/TU.
774 .debug_info calls this "dwo_id", .debug_types calls this "signature".
775 Since signatures came first, we stick with it for consistency. */
778 /* The section this CU/TU lives in, in the DWO file. */
779 struct dwarf2_section_info
*section
;
781 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
785 /* For types, offset in the type's DIE of the type defined by this TU. */
786 cu_offset type_offset_in_tu
;
789 /* include/dwarf2.h defines the DWP section codes.
790 It defines a max value but it doesn't define a min value, which we
791 use for error checking, so provide one. */
793 enum dwp_v2_section_ids
798 /* Data for one DWO file.
800 This includes virtual DWO files (a virtual DWO file is a DWO file as it
801 appears in a DWP file). DWP files don't really have DWO files per se -
802 comdat folding of types "loses" the DWO file they came from, and from
803 a high level view DWP files appear to contain a mass of random types.
804 However, to maintain consistency with the non-DWP case we pretend DWP
805 files contain virtual DWO files, and we assign each TU with one virtual
806 DWO file (generally based on the line and abbrev section offsets -
807 a heuristic that seems to work in practice). */
811 /* The DW_AT_GNU_dwo_name attribute.
812 For virtual DWO files the name is constructed from the section offsets
813 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
814 from related CU+TUs. */
815 const char *dwo_name
;
817 /* The DW_AT_comp_dir attribute. */
818 const char *comp_dir
;
820 /* The bfd, when the file is open. Otherwise this is NULL.
821 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
824 /* The sections that make up this DWO file.
825 Remember that for virtual DWO files in DWP V2, these are virtual
826 sections (for lack of a better name). */
827 struct dwo_sections sections
;
829 /* The CU in the file.
830 We only support one because having more than one requires hacking the
831 dwo_name of each to match, which is highly unlikely to happen.
832 Doing this means all TUs can share comp_dir: We also assume that
833 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
836 /* Table of TUs in the file.
837 Each element is a struct dwo_unit. */
841 /* These sections are what may appear in a DWP file. */
845 /* These are used by both DWP version 1 and 2. */
846 struct dwarf2_section_info str
;
847 struct dwarf2_section_info cu_index
;
848 struct dwarf2_section_info tu_index
;
850 /* These are only used by DWP version 2 files.
851 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
852 sections are referenced by section number, and are not recorded here.
853 In DWP version 2 there is at most one copy of all these sections, each
854 section being (effectively) comprised of the concatenation of all of the
855 individual sections that exist in the version 1 format.
856 To keep the code simple we treat each of these concatenated pieces as a
857 section itself (a virtual section?). */
858 struct dwarf2_section_info abbrev
;
859 struct dwarf2_section_info info
;
860 struct dwarf2_section_info line
;
861 struct dwarf2_section_info loc
;
862 struct dwarf2_section_info macinfo
;
863 struct dwarf2_section_info macro
;
864 struct dwarf2_section_info str_offsets
;
865 struct dwarf2_section_info types
;
868 /* These sections are what may appear in a virtual DWO file in DWP version 1.
869 A virtual DWO file is a DWO file as it appears in a DWP file. */
871 struct virtual_v1_dwo_sections
873 struct dwarf2_section_info abbrev
;
874 struct dwarf2_section_info line
;
875 struct dwarf2_section_info loc
;
876 struct dwarf2_section_info macinfo
;
877 struct dwarf2_section_info macro
;
878 struct dwarf2_section_info str_offsets
;
879 /* Each DWP hash table entry records one CU or one TU.
880 That is recorded here, and copied to dwo_unit.section. */
881 struct dwarf2_section_info info_or_types
;
884 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
885 In version 2, the sections of the DWO files are concatenated together
886 and stored in one section of that name. Thus each ELF section contains
887 several "virtual" sections. */
889 struct virtual_v2_dwo_sections
891 bfd_size_type abbrev_offset
;
892 bfd_size_type abbrev_size
;
894 bfd_size_type line_offset
;
895 bfd_size_type line_size
;
897 bfd_size_type loc_offset
;
898 bfd_size_type loc_size
;
900 bfd_size_type macinfo_offset
;
901 bfd_size_type macinfo_size
;
903 bfd_size_type macro_offset
;
904 bfd_size_type macro_size
;
906 bfd_size_type str_offsets_offset
;
907 bfd_size_type str_offsets_size
;
909 /* Each DWP hash table entry records one CU or one TU.
910 That is recorded here, and copied to dwo_unit.section. */
911 bfd_size_type info_or_types_offset
;
912 bfd_size_type info_or_types_size
;
915 /* Contents of DWP hash tables. */
917 struct dwp_hash_table
919 uint32_t version
, nr_columns
;
920 uint32_t nr_units
, nr_slots
;
921 const gdb_byte
*hash_table
, *unit_table
;
926 const gdb_byte
*indices
;
930 /* This is indexed by column number and gives the id of the section
932 #define MAX_NR_V2_DWO_SECTIONS \
933 (1 /* .debug_info or .debug_types */ \
934 + 1 /* .debug_abbrev */ \
935 + 1 /* .debug_line */ \
936 + 1 /* .debug_loc */ \
937 + 1 /* .debug_str_offsets */ \
938 + 1 /* .debug_macro or .debug_macinfo */)
939 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
940 const gdb_byte
*offsets
;
941 const gdb_byte
*sizes
;
946 /* Data for one DWP file. */
950 /* Name of the file. */
953 /* File format version. */
959 /* Section info for this file. */
960 struct dwp_sections sections
;
962 /* Table of CUs in the file. */
963 const struct dwp_hash_table
*cus
;
965 /* Table of TUs in the file. */
966 const struct dwp_hash_table
*tus
;
968 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
972 /* Table to map ELF section numbers to their sections.
973 This is only needed for the DWP V1 file format. */
974 unsigned int num_sections
;
975 asection
**elf_sections
;
978 /* This represents a '.dwz' file. */
982 /* A dwz file can only contain a few sections. */
983 struct dwarf2_section_info abbrev
;
984 struct dwarf2_section_info info
;
985 struct dwarf2_section_info str
;
986 struct dwarf2_section_info line
;
987 struct dwarf2_section_info macro
;
988 struct dwarf2_section_info gdb_index
;
994 /* Struct used to pass misc. parameters to read_die_and_children, et
995 al. which are used for both .debug_info and .debug_types dies.
996 All parameters here are unchanging for the life of the call. This
997 struct exists to abstract away the constant parameters of die reading. */
999 struct die_reader_specs
1001 /* The bfd of die_section. */
1004 /* The CU of the DIE we are parsing. */
1005 struct dwarf2_cu
*cu
;
1007 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1008 struct dwo_file
*dwo_file
;
1010 /* The section the die comes from.
1011 This is either .debug_info or .debug_types, or the .dwo variants. */
1012 struct dwarf2_section_info
*die_section
;
1014 /* die_section->buffer. */
1015 const gdb_byte
*buffer
;
1017 /* The end of the buffer. */
1018 const gdb_byte
*buffer_end
;
1020 /* The value of the DW_AT_comp_dir attribute. */
1021 const char *comp_dir
;
1024 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1025 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
1026 const gdb_byte
*info_ptr
,
1027 struct die_info
*comp_unit_die
,
1034 unsigned int dir_index
;
1035 unsigned int mod_time
;
1036 unsigned int length
;
1037 /* Non-zero if referenced by the Line Number Program. */
1039 /* The associated symbol table, if any. */
1040 struct symtab
*symtab
;
1043 /* The line number information for a compilation unit (found in the
1044 .debug_line section) begins with a "statement program header",
1045 which contains the following information. */
1048 /* Offset of line number information in .debug_line section. */
1051 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1052 unsigned offset_in_dwz
: 1;
1054 unsigned int total_length
;
1055 unsigned short version
;
1056 unsigned int header_length
;
1057 unsigned char minimum_instruction_length
;
1058 unsigned char maximum_ops_per_instruction
;
1059 unsigned char default_is_stmt
;
1061 unsigned char line_range
;
1062 unsigned char opcode_base
;
1064 /* standard_opcode_lengths[i] is the number of operands for the
1065 standard opcode whose value is i. This means that
1066 standard_opcode_lengths[0] is unused, and the last meaningful
1067 element is standard_opcode_lengths[opcode_base - 1]. */
1068 unsigned char *standard_opcode_lengths
;
1070 /* The include_directories table. NOTE! These strings are not
1071 allocated with xmalloc; instead, they are pointers into
1072 debug_line_buffer. If you try to free them, `free' will get
1074 unsigned int num_include_dirs
, include_dirs_size
;
1075 const char **include_dirs
;
1077 /* The file_names table. NOTE! These strings are not allocated
1078 with xmalloc; instead, they are pointers into debug_line_buffer.
1079 Don't try to free them directly. */
1080 unsigned int num_file_names
, file_names_size
;
1081 struct file_entry
*file_names
;
1083 /* The start and end of the statement program following this
1084 header. These point into dwarf2_per_objfile->line_buffer. */
1085 const gdb_byte
*statement_program_start
, *statement_program_end
;
1088 /* When we construct a partial symbol table entry we only
1089 need this much information. */
1090 struct partial_die_info
1092 /* Offset of this DIE. */
1095 /* DWARF-2 tag for this DIE. */
1096 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1098 /* Assorted flags describing the data found in this DIE. */
1099 unsigned int has_children
: 1;
1100 unsigned int is_external
: 1;
1101 unsigned int is_declaration
: 1;
1102 unsigned int has_type
: 1;
1103 unsigned int has_specification
: 1;
1104 unsigned int has_pc_info
: 1;
1105 unsigned int may_be_inlined
: 1;
1107 /* Flag set if the SCOPE field of this structure has been
1109 unsigned int scope_set
: 1;
1111 /* Flag set if the DIE has a byte_size attribute. */
1112 unsigned int has_byte_size
: 1;
1114 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1115 unsigned int has_const_value
: 1;
1117 /* Flag set if any of the DIE's children are template arguments. */
1118 unsigned int has_template_arguments
: 1;
1120 /* Flag set if fixup_partial_die has been called on this die. */
1121 unsigned int fixup_called
: 1;
1123 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1124 unsigned int is_dwz
: 1;
1126 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1127 unsigned int spec_is_dwz
: 1;
1129 /* The name of this DIE. Normally the value of DW_AT_name, but
1130 sometimes a default name for unnamed DIEs. */
1133 /* The linkage name, if present. */
1134 const char *linkage_name
;
1136 /* The scope to prepend to our children. This is generally
1137 allocated on the comp_unit_obstack, so will disappear
1138 when this compilation unit leaves the cache. */
1141 /* Some data associated with the partial DIE. The tag determines
1142 which field is live. */
1145 /* The location description associated with this DIE, if any. */
1146 struct dwarf_block
*locdesc
;
1147 /* The offset of an import, for DW_TAG_imported_unit. */
1151 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1155 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1156 DW_AT_sibling, if any. */
1157 /* NOTE: This member isn't strictly necessary, read_partial_die could
1158 return DW_AT_sibling values to its caller load_partial_dies. */
1159 const gdb_byte
*sibling
;
1161 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1162 DW_AT_specification (or DW_AT_abstract_origin or
1163 DW_AT_extension). */
1164 sect_offset spec_offset
;
1166 /* Pointers to this DIE's parent, first child, and next sibling,
1168 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
1171 /* This data structure holds the information of an abbrev. */
1174 unsigned int number
; /* number identifying abbrev */
1175 enum dwarf_tag tag
; /* dwarf tag */
1176 unsigned short has_children
; /* boolean */
1177 unsigned short num_attrs
; /* number of attributes */
1178 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1179 struct abbrev_info
*next
; /* next in chain */
1184 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1185 ENUM_BITFIELD(dwarf_form
) form
: 16;
1188 /* Size of abbrev_table.abbrev_hash_table. */
1189 #define ABBREV_HASH_SIZE 121
1191 /* Top level data structure to contain an abbreviation table. */
1195 /* Where the abbrev table came from.
1196 This is used as a sanity check when the table is used. */
1199 /* Storage for the abbrev table. */
1200 struct obstack abbrev_obstack
;
1202 /* Hash table of abbrevs.
1203 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1204 It could be statically allocated, but the previous code didn't so we
1206 struct abbrev_info
**abbrevs
;
1209 /* Attributes have a name and a value. */
1212 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1213 ENUM_BITFIELD(dwarf_form
) form
: 15;
1215 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1216 field should be in u.str (existing only for DW_STRING) but it is kept
1217 here for better struct attribute alignment. */
1218 unsigned int string_is_canonical
: 1;
1223 struct dwarf_block
*blk
;
1232 /* This data structure holds a complete die structure. */
1235 /* DWARF-2 tag for this DIE. */
1236 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1238 /* Number of attributes */
1239 unsigned char num_attrs
;
1241 /* True if we're presently building the full type name for the
1242 type derived from this DIE. */
1243 unsigned char building_fullname
: 1;
1245 /* True if this die is in process. PR 16581. */
1246 unsigned char in_process
: 1;
1249 unsigned int abbrev
;
1251 /* Offset in .debug_info or .debug_types section. */
1254 /* The dies in a compilation unit form an n-ary tree. PARENT
1255 points to this die's parent; CHILD points to the first child of
1256 this node; and all the children of a given node are chained
1257 together via their SIBLING fields. */
1258 struct die_info
*child
; /* Its first child, if any. */
1259 struct die_info
*sibling
; /* Its next sibling, if any. */
1260 struct die_info
*parent
; /* Its parent, if any. */
1262 /* An array of attributes, with NUM_ATTRS elements. There may be
1263 zero, but it's not common and zero-sized arrays are not
1264 sufficiently portable C. */
1265 struct attribute attrs
[1];
1268 /* Get at parts of an attribute structure. */
1270 #define DW_STRING(attr) ((attr)->u.str)
1271 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1272 #define DW_UNSND(attr) ((attr)->u.unsnd)
1273 #define DW_BLOCK(attr) ((attr)->u.blk)
1274 #define DW_SND(attr) ((attr)->u.snd)
1275 #define DW_ADDR(attr) ((attr)->u.addr)
1276 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1278 /* Blocks are a bunch of untyped bytes. */
1283 /* Valid only if SIZE is not zero. */
1284 const gdb_byte
*data
;
1287 #ifndef ATTR_ALLOC_CHUNK
1288 #define ATTR_ALLOC_CHUNK 4
1291 /* Allocate fields for structs, unions and enums in this size. */
1292 #ifndef DW_FIELD_ALLOC_CHUNK
1293 #define DW_FIELD_ALLOC_CHUNK 4
1296 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1297 but this would require a corresponding change in unpack_field_as_long
1299 static int bits_per_byte
= 8;
1303 struct nextfield
*next
;
1311 struct nextfnfield
*next
;
1312 struct fn_field fnfield
;
1319 struct nextfnfield
*head
;
1322 struct typedef_field_list
1324 struct typedef_field field
;
1325 struct typedef_field_list
*next
;
1328 /* The routines that read and process dies for a C struct or C++ class
1329 pass lists of data member fields and lists of member function fields
1330 in an instance of a field_info structure, as defined below. */
1333 /* List of data member and baseclasses fields. */
1334 struct nextfield
*fields
, *baseclasses
;
1336 /* Number of fields (including baseclasses). */
1339 /* Number of baseclasses. */
1342 /* Set if the accesibility of one of the fields is not public. */
1343 int non_public_fields
;
1345 /* Member function fields array, entries are allocated in the order they
1346 are encountered in the object file. */
1347 struct nextfnfield
*fnfields
;
1349 /* Member function fieldlist array, contains name of possibly overloaded
1350 member function, number of overloaded member functions and a pointer
1351 to the head of the member function field chain. */
1352 struct fnfieldlist
*fnfieldlists
;
1354 /* Number of entries in the fnfieldlists array. */
1357 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1358 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1359 struct typedef_field_list
*typedef_field_list
;
1360 unsigned typedef_field_list_count
;
1363 /* One item on the queue of compilation units to read in full symbols
1365 struct dwarf2_queue_item
1367 struct dwarf2_per_cu_data
*per_cu
;
1368 enum language pretend_language
;
1369 struct dwarf2_queue_item
*next
;
1372 /* The current queue. */
1373 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1375 /* Loaded secondary compilation units are kept in memory until they
1376 have not been referenced for the processing of this many
1377 compilation units. Set this to zero to disable caching. Cache
1378 sizes of up to at least twenty will improve startup time for
1379 typical inter-CU-reference binaries, at an obvious memory cost. */
1380 static int dwarf_max_cache_age
= 5;
1382 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1383 struct cmd_list_element
*c
, const char *value
)
1385 fprintf_filtered (file
, _("The upper bound on the age of cached "
1386 "DWARF compilation units is %s.\n"),
1390 /* local function prototypes */
1392 static const char *get_section_name (const struct dwarf2_section_info
*);
1394 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1396 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1398 static void dwarf2_find_base_address (struct die_info
*die
,
1399 struct dwarf2_cu
*cu
);
1401 static struct partial_symtab
*create_partial_symtab
1402 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1404 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1406 static void scan_partial_symbols (struct partial_die_info
*,
1407 CORE_ADDR
*, CORE_ADDR
*,
1408 int, struct dwarf2_cu
*);
1410 static void add_partial_symbol (struct partial_die_info
*,
1411 struct dwarf2_cu
*);
1413 static void add_partial_namespace (struct partial_die_info
*pdi
,
1414 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1415 int set_addrmap
, struct dwarf2_cu
*cu
);
1417 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1418 CORE_ADDR
*highpc
, int set_addrmap
,
1419 struct dwarf2_cu
*cu
);
1421 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1422 struct dwarf2_cu
*cu
);
1424 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1425 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1426 int need_pc
, struct dwarf2_cu
*cu
);
1428 static void dwarf2_read_symtab (struct partial_symtab
*,
1431 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1433 static struct abbrev_info
*abbrev_table_lookup_abbrev
1434 (const struct abbrev_table
*, unsigned int);
1436 static struct abbrev_table
*abbrev_table_read_table
1437 (struct dwarf2_section_info
*, sect_offset
);
1439 static void abbrev_table_free (struct abbrev_table
*);
1441 static void abbrev_table_free_cleanup (void *);
1443 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1444 struct dwarf2_section_info
*);
1446 static void dwarf2_free_abbrev_table (void *);
1448 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1450 static struct partial_die_info
*load_partial_dies
1451 (const struct die_reader_specs
*, const gdb_byte
*, int);
1453 static const gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1454 struct partial_die_info
*,
1455 struct abbrev_info
*,
1459 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1460 struct dwarf2_cu
*);
1462 static void fixup_partial_die (struct partial_die_info
*,
1463 struct dwarf2_cu
*);
1465 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1466 struct attribute
*, struct attr_abbrev
*,
1469 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1471 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1473 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1475 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1477 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1479 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1482 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1484 static LONGEST read_checked_initial_length_and_offset
1485 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1486 unsigned int *, unsigned int *);
1488 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1489 const struct comp_unit_head
*,
1492 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1494 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1497 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1499 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1501 static const char *read_indirect_string (bfd
*, const gdb_byte
*,
1502 const struct comp_unit_head
*,
1505 static const char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1507 static ULONGEST
read_unsigned_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1509 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1511 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1515 static const char *read_str_index (const struct die_reader_specs
*reader
,
1516 ULONGEST str_index
);
1518 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1520 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1521 struct dwarf2_cu
*);
1523 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1526 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1527 struct dwarf2_cu
*cu
);
1529 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1531 static struct die_info
*die_specification (struct die_info
*die
,
1532 struct dwarf2_cu
**);
1534 static void free_line_header (struct line_header
*lh
);
1536 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1537 struct dwarf2_cu
*cu
);
1539 static void dwarf_decode_lines (struct line_header
*, const char *,
1540 struct dwarf2_cu
*, struct partial_symtab
*,
1541 CORE_ADDR
, int decode_mapping
);
1543 static void dwarf2_start_subfile (const char *, const char *);
1545 static struct compunit_symtab
*dwarf2_start_symtab (struct dwarf2_cu
*,
1546 const char *, const char *,
1549 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1550 struct dwarf2_cu
*);
1552 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1553 struct dwarf2_cu
*, struct symbol
*);
1555 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1556 struct dwarf2_cu
*);
1558 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1561 struct obstack
*obstack
,
1562 struct dwarf2_cu
*cu
, LONGEST
*value
,
1563 const gdb_byte
**bytes
,
1564 struct dwarf2_locexpr_baton
**baton
);
1566 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1568 static int need_gnat_info (struct dwarf2_cu
*);
1570 static struct type
*die_descriptive_type (struct die_info
*,
1571 struct dwarf2_cu
*);
1573 static void set_descriptive_type (struct type
*, struct die_info
*,
1574 struct dwarf2_cu
*);
1576 static struct type
*die_containing_type (struct die_info
*,
1577 struct dwarf2_cu
*);
1579 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1580 struct dwarf2_cu
*);
1582 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1584 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1586 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1588 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1589 const char *suffix
, int physname
,
1590 struct dwarf2_cu
*cu
);
1592 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1594 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1596 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1598 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1600 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1602 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1603 struct dwarf2_cu
*, struct partial_symtab
*);
1605 static int dwarf2_get_pc_bounds (struct die_info
*,
1606 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1607 struct partial_symtab
*);
1609 static void get_scope_pc_bounds (struct die_info
*,
1610 CORE_ADDR
*, CORE_ADDR
*,
1611 struct dwarf2_cu
*);
1613 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1614 CORE_ADDR
, struct dwarf2_cu
*);
1616 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1617 struct dwarf2_cu
*);
1619 static void dwarf2_attach_fields_to_type (struct field_info
*,
1620 struct type
*, struct dwarf2_cu
*);
1622 static void dwarf2_add_member_fn (struct field_info
*,
1623 struct die_info
*, struct type
*,
1624 struct dwarf2_cu
*);
1626 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1628 struct dwarf2_cu
*);
1630 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1632 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1634 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1636 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1638 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1640 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1642 static struct type
*read_module_type (struct die_info
*die
,
1643 struct dwarf2_cu
*cu
);
1645 static const char *namespace_name (struct die_info
*die
,
1646 int *is_anonymous
, struct dwarf2_cu
*);
1648 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1650 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1652 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1653 struct dwarf2_cu
*);
1655 static struct die_info
*read_die_and_siblings_1
1656 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1659 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1660 const gdb_byte
*info_ptr
,
1661 const gdb_byte
**new_info_ptr
,
1662 struct die_info
*parent
);
1664 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1665 struct die_info
**, const gdb_byte
*,
1668 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1669 struct die_info
**, const gdb_byte
*,
1672 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1674 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1677 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1679 static const char *dwarf2_full_name (const char *name
,
1680 struct die_info
*die
,
1681 struct dwarf2_cu
*cu
);
1683 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1684 struct dwarf2_cu
*cu
);
1686 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1687 struct dwarf2_cu
**);
1689 static const char *dwarf_tag_name (unsigned int);
1691 static const char *dwarf_attr_name (unsigned int);
1693 static const char *dwarf_form_name (unsigned int);
1695 static char *dwarf_bool_name (unsigned int);
1697 static const char *dwarf_type_encoding_name (unsigned int);
1699 static struct die_info
*sibling_die (struct die_info
*);
1701 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1703 static void dump_die_for_error (struct die_info
*);
1705 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1708 /*static*/ void dump_die (struct die_info
*, int max_level
);
1710 static void store_in_ref_table (struct die_info
*,
1711 struct dwarf2_cu
*);
1713 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1715 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1717 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1718 const struct attribute
*,
1719 struct dwarf2_cu
**);
1721 static struct die_info
*follow_die_ref (struct die_info
*,
1722 const struct attribute
*,
1723 struct dwarf2_cu
**);
1725 static struct die_info
*follow_die_sig (struct die_info
*,
1726 const struct attribute
*,
1727 struct dwarf2_cu
**);
1729 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1730 struct dwarf2_cu
*);
1732 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1733 const struct attribute
*,
1734 struct dwarf2_cu
*);
1736 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1738 static void read_signatured_type (struct signatured_type
*);
1740 /* memory allocation interface */
1742 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1744 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1746 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1748 static int attr_form_is_block (const struct attribute
*);
1750 static int attr_form_is_section_offset (const struct attribute
*);
1752 static int attr_form_is_constant (const struct attribute
*);
1754 static int attr_form_is_ref (const struct attribute
*);
1756 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1757 struct dwarf2_loclist_baton
*baton
,
1758 const struct attribute
*attr
);
1760 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1762 struct dwarf2_cu
*cu
,
1765 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1766 const gdb_byte
*info_ptr
,
1767 struct abbrev_info
*abbrev
);
1769 static void free_stack_comp_unit (void *);
1771 static hashval_t
partial_die_hash (const void *item
);
1773 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1775 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1776 (sect_offset offset
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
1778 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1779 struct dwarf2_per_cu_data
*per_cu
);
1781 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1782 struct die_info
*comp_unit_die
,
1783 enum language pretend_language
);
1785 static void free_heap_comp_unit (void *);
1787 static void free_cached_comp_units (void *);
1789 static void age_cached_comp_units (void);
1791 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1793 static struct type
*set_die_type (struct die_info
*, struct type
*,
1794 struct dwarf2_cu
*);
1796 static void create_all_comp_units (struct objfile
*);
1798 static int create_all_type_units (struct objfile
*);
1800 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1803 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1806 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1809 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1810 struct dwarf2_per_cu_data
*);
1812 static void dwarf2_mark (struct dwarf2_cu
*);
1814 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1816 static struct type
*get_die_type_at_offset (sect_offset
,
1817 struct dwarf2_per_cu_data
*);
1819 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1821 static void dwarf2_release_queue (void *dummy
);
1823 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1824 enum language pretend_language
);
1826 static void process_queue (void);
1828 static void find_file_and_directory (struct die_info
*die
,
1829 struct dwarf2_cu
*cu
,
1830 const char **name
, const char **comp_dir
);
1832 static char *file_full_name (int file
, struct line_header
*lh
,
1833 const char *comp_dir
);
1835 static const gdb_byte
*read_and_check_comp_unit_head
1836 (struct comp_unit_head
*header
,
1837 struct dwarf2_section_info
*section
,
1838 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1839 int is_debug_types_section
);
1841 static void init_cutu_and_read_dies
1842 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1843 int use_existing_cu
, int keep
,
1844 die_reader_func_ftype
*die_reader_func
, void *data
);
1846 static void init_cutu_and_read_dies_simple
1847 (struct dwarf2_per_cu_data
*this_cu
,
1848 die_reader_func_ftype
*die_reader_func
, void *data
);
1850 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1852 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1854 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1855 (struct dwp_file
*dwp_file
, const char *comp_dir
,
1856 ULONGEST signature
, int is_debug_types
);
1858 static struct dwp_file
*get_dwp_file (void);
1860 static struct dwo_unit
*lookup_dwo_comp_unit
1861 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1863 static struct dwo_unit
*lookup_dwo_type_unit
1864 (struct signatured_type
*, const char *, const char *);
1866 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
1868 static void free_dwo_file_cleanup (void *);
1870 static void process_cu_includes (void);
1872 static void check_producer (struct dwarf2_cu
*cu
);
1874 static void free_line_header_voidp (void *arg
);
1876 /* Various complaints about symbol reading that don't abort the process. */
1879 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1881 complaint (&symfile_complaints
,
1882 _("statement list doesn't fit in .debug_line section"));
1886 dwarf2_debug_line_missing_file_complaint (void)
1888 complaint (&symfile_complaints
,
1889 _(".debug_line section has line data without a file"));
1893 dwarf2_debug_line_missing_end_sequence_complaint (void)
1895 complaint (&symfile_complaints
,
1896 _(".debug_line section has line "
1897 "program sequence without an end"));
1901 dwarf2_complex_location_expr_complaint (void)
1903 complaint (&symfile_complaints
, _("location expression too complex"));
1907 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1910 complaint (&symfile_complaints
,
1911 _("const value length mismatch for '%s', got %d, expected %d"),
1916 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1918 complaint (&symfile_complaints
,
1919 _("debug info runs off end of %s section"
1921 get_section_name (section
),
1922 get_section_file_name (section
));
1926 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1928 complaint (&symfile_complaints
,
1929 _("macro debug info contains a "
1930 "malformed macro definition:\n`%s'"),
1935 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1937 complaint (&symfile_complaints
,
1938 _("invalid attribute class or form for '%s' in '%s'"),
1942 /* Hash function for line_header_hash. */
1945 line_header_hash (const struct line_header
*ofs
)
1947 return ofs
->offset
.sect_off
^ ofs
->offset_in_dwz
;
1950 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1953 line_header_hash_voidp (const void *item
)
1955 const struct line_header
*ofs
= item
;
1957 return line_header_hash (ofs
);
1960 /* Equality function for line_header_hash. */
1963 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1965 const struct line_header
*ofs_lhs
= item_lhs
;
1966 const struct line_header
*ofs_rhs
= item_rhs
;
1968 return (ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
1969 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1975 /* Convert VALUE between big- and little-endian. */
1977 byte_swap (offset_type value
)
1981 result
= (value
& 0xff) << 24;
1982 result
|= (value
& 0xff00) << 8;
1983 result
|= (value
& 0xff0000) >> 8;
1984 result
|= (value
& 0xff000000) >> 24;
1988 #define MAYBE_SWAP(V) byte_swap (V)
1991 #define MAYBE_SWAP(V) (V)
1992 #endif /* WORDS_BIGENDIAN */
1994 /* Read the given attribute value as an address, taking the attribute's
1995 form into account. */
1998 attr_value_as_address (struct attribute
*attr
)
2002 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_GNU_addr_index
)
2004 /* Aside from a few clearly defined exceptions, attributes that
2005 contain an address must always be in DW_FORM_addr form.
2006 Unfortunately, some compilers happen to be violating this
2007 requirement by encoding addresses using other forms, such
2008 as DW_FORM_data4 for example. For those broken compilers,
2009 we try to do our best, without any guarantee of success,
2010 to interpret the address correctly. It would also be nice
2011 to generate a complaint, but that would require us to maintain
2012 a list of legitimate cases where a non-address form is allowed,
2013 as well as update callers to pass in at least the CU's DWARF
2014 version. This is more overhead than what we're willing to
2015 expand for a pretty rare case. */
2016 addr
= DW_UNSND (attr
);
2019 addr
= DW_ADDR (attr
);
2024 /* The suffix for an index file. */
2025 #define INDEX_SUFFIX ".gdb-index"
2027 /* Try to locate the sections we need for DWARF 2 debugging
2028 information and return true if we have enough to do something.
2029 NAMES points to the dwarf2 section names, or is NULL if the standard
2030 ELF names are used. */
2033 dwarf2_has_info (struct objfile
*objfile
,
2034 const struct dwarf2_debug_sections
*names
)
2036 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2037 if (!dwarf2_per_objfile
)
2039 /* Initialize per-objfile state. */
2040 struct dwarf2_per_objfile
*data
2041 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
2043 memset (data
, 0, sizeof (*data
));
2044 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
2045 dwarf2_per_objfile
= data
;
2047 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
2049 dwarf2_per_objfile
->objfile
= objfile
;
2051 return (!dwarf2_per_objfile
->info
.is_virtual
2052 && dwarf2_per_objfile
->info
.s
.asection
!= NULL
2053 && !dwarf2_per_objfile
->abbrev
.is_virtual
2054 && dwarf2_per_objfile
->abbrev
.s
.asection
!= NULL
);
2057 /* Return the containing section of virtual section SECTION. */
2059 static struct dwarf2_section_info
*
2060 get_containing_section (const struct dwarf2_section_info
*section
)
2062 gdb_assert (section
->is_virtual
);
2063 return section
->s
.containing_section
;
2066 /* Return the bfd owner of SECTION. */
2069 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2071 if (section
->is_virtual
)
2073 section
= get_containing_section (section
);
2074 gdb_assert (!section
->is_virtual
);
2076 return section
->s
.asection
->owner
;
2079 /* Return the bfd section of SECTION.
2080 Returns NULL if the section is not present. */
2083 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2085 if (section
->is_virtual
)
2087 section
= get_containing_section (section
);
2088 gdb_assert (!section
->is_virtual
);
2090 return section
->s
.asection
;
2093 /* Return the name of SECTION. */
2096 get_section_name (const struct dwarf2_section_info
*section
)
2098 asection
*sectp
= get_section_bfd_section (section
);
2100 gdb_assert (sectp
!= NULL
);
2101 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2104 /* Return the name of the file SECTION is in. */
2107 get_section_file_name (const struct dwarf2_section_info
*section
)
2109 bfd
*abfd
= get_section_bfd_owner (section
);
2111 return bfd_get_filename (abfd
);
2114 /* Return the id of SECTION.
2115 Returns 0 if SECTION doesn't exist. */
2118 get_section_id (const struct dwarf2_section_info
*section
)
2120 asection
*sectp
= get_section_bfd_section (section
);
2127 /* Return the flags of SECTION.
2128 SECTION (or containing section if this is a virtual section) must exist. */
2131 get_section_flags (const struct dwarf2_section_info
*section
)
2133 asection
*sectp
= get_section_bfd_section (section
);
2135 gdb_assert (sectp
!= NULL
);
2136 return bfd_get_section_flags (sectp
->owner
, sectp
);
2139 /* When loading sections, we look either for uncompressed section or for
2140 compressed section names. */
2143 section_is_p (const char *section_name
,
2144 const struct dwarf2_section_names
*names
)
2146 if (names
->normal
!= NULL
2147 && strcmp (section_name
, names
->normal
) == 0)
2149 if (names
->compressed
!= NULL
2150 && strcmp (section_name
, names
->compressed
) == 0)
2155 /* This function is mapped across the sections and remembers the
2156 offset and size of each of the debugging sections we are interested
2160 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
2162 const struct dwarf2_debug_sections
*names
;
2163 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2166 names
= &dwarf2_elf_names
;
2168 names
= (const struct dwarf2_debug_sections
*) vnames
;
2170 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2173 else if (section_is_p (sectp
->name
, &names
->info
))
2175 dwarf2_per_objfile
->info
.s
.asection
= sectp
;
2176 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
2178 else if (section_is_p (sectp
->name
, &names
->abbrev
))
2180 dwarf2_per_objfile
->abbrev
.s
.asection
= sectp
;
2181 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
2183 else if (section_is_p (sectp
->name
, &names
->line
))
2185 dwarf2_per_objfile
->line
.s
.asection
= sectp
;
2186 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
2188 else if (section_is_p (sectp
->name
, &names
->loc
))
2190 dwarf2_per_objfile
->loc
.s
.asection
= sectp
;
2191 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
2193 else if (section_is_p (sectp
->name
, &names
->macinfo
))
2195 dwarf2_per_objfile
->macinfo
.s
.asection
= sectp
;
2196 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
2198 else if (section_is_p (sectp
->name
, &names
->macro
))
2200 dwarf2_per_objfile
->macro
.s
.asection
= sectp
;
2201 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
2203 else if (section_is_p (sectp
->name
, &names
->str
))
2205 dwarf2_per_objfile
->str
.s
.asection
= sectp
;
2206 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
2208 else if (section_is_p (sectp
->name
, &names
->addr
))
2210 dwarf2_per_objfile
->addr
.s
.asection
= sectp
;
2211 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
2213 else if (section_is_p (sectp
->name
, &names
->frame
))
2215 dwarf2_per_objfile
->frame
.s
.asection
= sectp
;
2216 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
2218 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
2220 dwarf2_per_objfile
->eh_frame
.s
.asection
= sectp
;
2221 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
2223 else if (section_is_p (sectp
->name
, &names
->ranges
))
2225 dwarf2_per_objfile
->ranges
.s
.asection
= sectp
;
2226 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
2228 else if (section_is_p (sectp
->name
, &names
->types
))
2230 struct dwarf2_section_info type_section
;
2232 memset (&type_section
, 0, sizeof (type_section
));
2233 type_section
.s
.asection
= sectp
;
2234 type_section
.size
= bfd_get_section_size (sectp
);
2236 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
2239 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
2241 dwarf2_per_objfile
->gdb_index
.s
.asection
= sectp
;
2242 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
2245 if ((bfd_get_section_flags (abfd
, sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2246 && bfd_section_vma (abfd
, sectp
) == 0)
2247 dwarf2_per_objfile
->has_section_at_zero
= 1;
2250 /* A helper function that decides whether a section is empty,
2254 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2256 if (section
->is_virtual
)
2257 return section
->size
== 0;
2258 return section
->s
.asection
== NULL
|| section
->size
== 0;
2261 /* Read the contents of the section INFO.
2262 OBJFILE is the main object file, but not necessarily the file where
2263 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2265 If the section is compressed, uncompress it before returning. */
2268 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
2272 gdb_byte
*buf
, *retbuf
;
2276 info
->buffer
= NULL
;
2279 if (dwarf2_section_empty_p (info
))
2282 sectp
= get_section_bfd_section (info
);
2284 /* If this is a virtual section we need to read in the real one first. */
2285 if (info
->is_virtual
)
2287 struct dwarf2_section_info
*containing_section
=
2288 get_containing_section (info
);
2290 gdb_assert (sectp
!= NULL
);
2291 if ((sectp
->flags
& SEC_RELOC
) != 0)
2293 error (_("Dwarf Error: DWP format V2 with relocations is not"
2294 " supported in section %s [in module %s]"),
2295 get_section_name (info
), get_section_file_name (info
));
2297 dwarf2_read_section (objfile
, containing_section
);
2298 /* Other code should have already caught virtual sections that don't
2300 gdb_assert (info
->virtual_offset
+ info
->size
2301 <= containing_section
->size
);
2302 /* If the real section is empty or there was a problem reading the
2303 section we shouldn't get here. */
2304 gdb_assert (containing_section
->buffer
!= NULL
);
2305 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2309 /* If the section has relocations, we must read it ourselves.
2310 Otherwise we attach it to the BFD. */
2311 if ((sectp
->flags
& SEC_RELOC
) == 0)
2313 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2317 buf
= obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2320 /* When debugging .o files, we may need to apply relocations; see
2321 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2322 We never compress sections in .o files, so we only need to
2323 try this when the section is not compressed. */
2324 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2327 info
->buffer
= retbuf
;
2331 abfd
= get_section_bfd_owner (info
);
2332 gdb_assert (abfd
!= NULL
);
2334 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2335 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2337 error (_("Dwarf Error: Can't read DWARF data"
2338 " in section %s [in module %s]"),
2339 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2343 /* A helper function that returns the size of a section in a safe way.
2344 If you are positive that the section has been read before using the
2345 size, then it is safe to refer to the dwarf2_section_info object's
2346 "size" field directly. In other cases, you must call this
2347 function, because for compressed sections the size field is not set
2348 correctly until the section has been read. */
2350 static bfd_size_type
2351 dwarf2_section_size (struct objfile
*objfile
,
2352 struct dwarf2_section_info
*info
)
2355 dwarf2_read_section (objfile
, info
);
2359 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2363 dwarf2_get_section_info (struct objfile
*objfile
,
2364 enum dwarf2_section_enum sect
,
2365 asection
**sectp
, const gdb_byte
**bufp
,
2366 bfd_size_type
*sizep
)
2368 struct dwarf2_per_objfile
*data
2369 = objfile_data (objfile
, dwarf2_objfile_data_key
);
2370 struct dwarf2_section_info
*info
;
2372 /* We may see an objfile without any DWARF, in which case we just
2383 case DWARF2_DEBUG_FRAME
:
2384 info
= &data
->frame
;
2386 case DWARF2_EH_FRAME
:
2387 info
= &data
->eh_frame
;
2390 gdb_assert_not_reached ("unexpected section");
2393 dwarf2_read_section (objfile
, info
);
2395 *sectp
= get_section_bfd_section (info
);
2396 *bufp
= info
->buffer
;
2397 *sizep
= info
->size
;
2400 /* A helper function to find the sections for a .dwz file. */
2403 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2405 struct dwz_file
*dwz_file
= arg
;
2407 /* Note that we only support the standard ELF names, because .dwz
2408 is ELF-only (at the time of writing). */
2409 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2411 dwz_file
->abbrev
.s
.asection
= sectp
;
2412 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2414 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2416 dwz_file
->info
.s
.asection
= sectp
;
2417 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2419 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2421 dwz_file
->str
.s
.asection
= sectp
;
2422 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2424 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2426 dwz_file
->line
.s
.asection
= sectp
;
2427 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2429 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2431 dwz_file
->macro
.s
.asection
= sectp
;
2432 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2434 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2436 dwz_file
->gdb_index
.s
.asection
= sectp
;
2437 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2441 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2442 there is no .gnu_debugaltlink section in the file. Error if there
2443 is such a section but the file cannot be found. */
2445 static struct dwz_file
*
2446 dwarf2_get_dwz_file (void)
2450 struct cleanup
*cleanup
;
2451 const char *filename
;
2452 struct dwz_file
*result
;
2453 bfd_size_type buildid_len_arg
;
2457 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2458 return dwarf2_per_objfile
->dwz_file
;
2460 bfd_set_error (bfd_error_no_error
);
2461 data
= bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2462 &buildid_len_arg
, &buildid
);
2465 if (bfd_get_error () == bfd_error_no_error
)
2467 error (_("could not read '.gnu_debugaltlink' section: %s"),
2468 bfd_errmsg (bfd_get_error ()));
2470 cleanup
= make_cleanup (xfree
, data
);
2471 make_cleanup (xfree
, buildid
);
2473 buildid_len
= (size_t) buildid_len_arg
;
2475 filename
= (const char *) data
;
2476 if (!IS_ABSOLUTE_PATH (filename
))
2478 char *abs
= gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2481 make_cleanup (xfree
, abs
);
2482 abs
= ldirname (abs
);
2483 make_cleanup (xfree
, abs
);
2485 rel
= concat (abs
, SLASH_STRING
, filename
, (char *) NULL
);
2486 make_cleanup (xfree
, rel
);
2490 /* First try the file name given in the section. If that doesn't
2491 work, try to use the build-id instead. */
2492 dwz_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2493 if (dwz_bfd
!= NULL
)
2495 if (!build_id_verify (dwz_bfd
, buildid_len
, buildid
))
2497 gdb_bfd_unref (dwz_bfd
);
2502 if (dwz_bfd
== NULL
)
2503 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2505 if (dwz_bfd
== NULL
)
2506 error (_("could not find '.gnu_debugaltlink' file for %s"),
2507 objfile_name (dwarf2_per_objfile
->objfile
));
2509 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2511 result
->dwz_bfd
= dwz_bfd
;
2513 bfd_map_over_sections (dwz_bfd
, locate_dwz_sections
, result
);
2515 do_cleanups (cleanup
);
2517 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, dwz_bfd
);
2518 dwarf2_per_objfile
->dwz_file
= result
;
2522 /* DWARF quick_symbols_functions support. */
2524 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2525 unique line tables, so we maintain a separate table of all .debug_line
2526 derived entries to support the sharing.
2527 All the quick functions need is the list of file names. We discard the
2528 line_header when we're done and don't need to record it here. */
2529 struct quick_file_names
2531 /* The data used to construct the hash key. */
2532 struct stmt_list_hash hash
;
2534 /* The number of entries in file_names, real_names. */
2535 unsigned int num_file_names
;
2537 /* The file names from the line table, after being run through
2539 const char **file_names
;
2541 /* The file names from the line table after being run through
2542 gdb_realpath. These are computed lazily. */
2543 const char **real_names
;
2546 /* When using the index (and thus not using psymtabs), each CU has an
2547 object of this type. This is used to hold information needed by
2548 the various "quick" methods. */
2549 struct dwarf2_per_cu_quick_data
2551 /* The file table. This can be NULL if there was no file table
2552 or it's currently not read in.
2553 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2554 struct quick_file_names
*file_names
;
2556 /* The corresponding symbol table. This is NULL if symbols for this
2557 CU have not yet been read. */
2558 struct compunit_symtab
*compunit_symtab
;
2560 /* A temporary mark bit used when iterating over all CUs in
2561 expand_symtabs_matching. */
2562 unsigned int mark
: 1;
2564 /* True if we've tried to read the file table and found there isn't one.
2565 There will be no point in trying to read it again next time. */
2566 unsigned int no_file_data
: 1;
2569 /* Utility hash function for a stmt_list_hash. */
2572 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2576 if (stmt_list_hash
->dwo_unit
!= NULL
)
2577 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2578 v
+= stmt_list_hash
->line_offset
.sect_off
;
2582 /* Utility equality function for a stmt_list_hash. */
2585 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2586 const struct stmt_list_hash
*rhs
)
2588 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2590 if (lhs
->dwo_unit
!= NULL
2591 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2594 return lhs
->line_offset
.sect_off
== rhs
->line_offset
.sect_off
;
2597 /* Hash function for a quick_file_names. */
2600 hash_file_name_entry (const void *e
)
2602 const struct quick_file_names
*file_data
= e
;
2604 return hash_stmt_list_entry (&file_data
->hash
);
2607 /* Equality function for a quick_file_names. */
2610 eq_file_name_entry (const void *a
, const void *b
)
2612 const struct quick_file_names
*ea
= a
;
2613 const struct quick_file_names
*eb
= b
;
2615 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2618 /* Delete function for a quick_file_names. */
2621 delete_file_name_entry (void *e
)
2623 struct quick_file_names
*file_data
= e
;
2626 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2628 xfree ((void*) file_data
->file_names
[i
]);
2629 if (file_data
->real_names
)
2630 xfree ((void*) file_data
->real_names
[i
]);
2633 /* The space for the struct itself lives on objfile_obstack,
2634 so we don't free it here. */
2637 /* Create a quick_file_names hash table. */
2640 create_quick_file_names_table (unsigned int nr_initial_entries
)
2642 return htab_create_alloc (nr_initial_entries
,
2643 hash_file_name_entry
, eq_file_name_entry
,
2644 delete_file_name_entry
, xcalloc
, xfree
);
2647 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2648 have to be created afterwards. You should call age_cached_comp_units after
2649 processing PER_CU->CU. dw2_setup must have been already called. */
2652 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2654 if (per_cu
->is_debug_types
)
2655 load_full_type_unit (per_cu
);
2657 load_full_comp_unit (per_cu
, language_minimal
);
2659 if (per_cu
->cu
== NULL
)
2660 return; /* Dummy CU. */
2662 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2665 /* Read in the symbols for PER_CU. */
2668 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2670 struct cleanup
*back_to
;
2672 /* Skip type_unit_groups, reading the type units they contain
2673 is handled elsewhere. */
2674 if (IS_TYPE_UNIT_GROUP (per_cu
))
2677 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2679 if (dwarf2_per_objfile
->using_index
2680 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2681 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2683 queue_comp_unit (per_cu
, language_minimal
);
2686 /* If we just loaded a CU from a DWO, and we're working with an index
2687 that may badly handle TUs, load all the TUs in that DWO as well.
2688 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2689 if (!per_cu
->is_debug_types
2690 && per_cu
->cu
!= NULL
2691 && per_cu
->cu
->dwo_unit
!= NULL
2692 && dwarf2_per_objfile
->index_table
!= NULL
2693 && dwarf2_per_objfile
->index_table
->version
<= 7
2694 /* DWP files aren't supported yet. */
2695 && get_dwp_file () == NULL
)
2696 queue_and_load_all_dwo_tus (per_cu
);
2701 /* Age the cache, releasing compilation units that have not
2702 been used recently. */
2703 age_cached_comp_units ();
2705 do_cleanups (back_to
);
2708 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2709 the objfile from which this CU came. Returns the resulting symbol
2712 static struct compunit_symtab
*
2713 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2715 gdb_assert (dwarf2_per_objfile
->using_index
);
2716 if (!per_cu
->v
.quick
->compunit_symtab
)
2718 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2719 increment_reading_symtab ();
2720 dw2_do_instantiate_symtab (per_cu
);
2721 process_cu_includes ();
2722 do_cleanups (back_to
);
2725 return per_cu
->v
.quick
->compunit_symtab
;
2728 /* Return the CU/TU given its index.
2730 This is intended for loops like:
2732 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2733 + dwarf2_per_objfile->n_type_units); ++i)
2735 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
2741 static struct dwarf2_per_cu_data
*
2742 dw2_get_cutu (int index
)
2744 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2746 index
-= dwarf2_per_objfile
->n_comp_units
;
2747 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
2748 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
2751 return dwarf2_per_objfile
->all_comp_units
[index
];
2754 /* Return the CU given its index.
2755 This differs from dw2_get_cutu in that it's for when you know INDEX
2758 static struct dwarf2_per_cu_data
*
2759 dw2_get_cu (int index
)
2761 gdb_assert (index
>= 0 && index
< dwarf2_per_objfile
->n_comp_units
);
2763 return dwarf2_per_objfile
->all_comp_units
[index
];
2766 /* A helper for create_cus_from_index that handles a given list of
2770 create_cus_from_index_list (struct objfile
*objfile
,
2771 const gdb_byte
*cu_list
, offset_type n_elements
,
2772 struct dwarf2_section_info
*section
,
2778 for (i
= 0; i
< n_elements
; i
+= 2)
2780 struct dwarf2_per_cu_data
*the_cu
;
2781 ULONGEST offset
, length
;
2783 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2784 offset
= extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2785 length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2788 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2789 struct dwarf2_per_cu_data
);
2790 the_cu
->offset
.sect_off
= offset
;
2791 the_cu
->length
= length
;
2792 the_cu
->objfile
= objfile
;
2793 the_cu
->section
= section
;
2794 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2795 struct dwarf2_per_cu_quick_data
);
2796 the_cu
->is_dwz
= is_dwz
;
2797 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
2801 /* Read the CU list from the mapped index, and use it to create all
2802 the CU objects for this objfile. */
2805 create_cus_from_index (struct objfile
*objfile
,
2806 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2807 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2809 struct dwz_file
*dwz
;
2811 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
2812 dwarf2_per_objfile
->all_comp_units
2813 = obstack_alloc (&objfile
->objfile_obstack
,
2814 dwarf2_per_objfile
->n_comp_units
2815 * sizeof (struct dwarf2_per_cu_data
*));
2817 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
2818 &dwarf2_per_objfile
->info
, 0, 0);
2820 if (dwz_elements
== 0)
2823 dwz
= dwarf2_get_dwz_file ();
2824 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
2825 cu_list_elements
/ 2);
2828 /* Create the signatured type hash table from the index. */
2831 create_signatured_type_table_from_index (struct objfile
*objfile
,
2832 struct dwarf2_section_info
*section
,
2833 const gdb_byte
*bytes
,
2834 offset_type elements
)
2837 htab_t sig_types_hash
;
2839 dwarf2_per_objfile
->n_type_units
2840 = dwarf2_per_objfile
->n_allocated_type_units
2842 dwarf2_per_objfile
->all_type_units
2843 = xmalloc (dwarf2_per_objfile
->n_type_units
2844 * sizeof (struct signatured_type
*));
2846 sig_types_hash
= allocate_signatured_type_table (objfile
);
2848 for (i
= 0; i
< elements
; i
+= 3)
2850 struct signatured_type
*sig_type
;
2851 ULONGEST offset
, type_offset_in_tu
, signature
;
2854 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2855 offset
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2856 type_offset_in_tu
= extract_unsigned_integer (bytes
+ 8, 8,
2858 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2861 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2862 struct signatured_type
);
2863 sig_type
->signature
= signature
;
2864 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2865 sig_type
->per_cu
.is_debug_types
= 1;
2866 sig_type
->per_cu
.section
= section
;
2867 sig_type
->per_cu
.offset
.sect_off
= offset
;
2868 sig_type
->per_cu
.objfile
= objfile
;
2869 sig_type
->per_cu
.v
.quick
2870 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2871 struct dwarf2_per_cu_quick_data
);
2873 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2876 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
2879 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2882 /* Read the address map data from the mapped index, and use it to
2883 populate the objfile's psymtabs_addrmap. */
2886 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2888 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2889 const gdb_byte
*iter
, *end
;
2890 struct obstack temp_obstack
;
2891 struct addrmap
*mutable_map
;
2892 struct cleanup
*cleanup
;
2895 obstack_init (&temp_obstack
);
2896 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2897 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2899 iter
= index
->address_table
;
2900 end
= iter
+ index
->address_table_size
;
2902 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2906 ULONGEST hi
, lo
, cu_index
;
2907 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2909 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2911 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2916 complaint (&symfile_complaints
,
2917 _(".gdb_index address table has invalid range (%s - %s)"),
2918 hex_string (lo
), hex_string (hi
));
2922 if (cu_index
>= dwarf2_per_objfile
->n_comp_units
)
2924 complaint (&symfile_complaints
,
2925 _(".gdb_index address table has invalid CU number %u"),
2926 (unsigned) cu_index
);
2930 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
);
2931 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
);
2932 addrmap_set_empty (mutable_map
, lo
, hi
- 1, dw2_get_cutu (cu_index
));
2935 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2936 &objfile
->objfile_obstack
);
2937 do_cleanups (cleanup
);
2940 /* The hash function for strings in the mapped index. This is the same as
2941 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2942 implementation. This is necessary because the hash function is tied to the
2943 format of the mapped index file. The hash values do not have to match with
2946 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2949 mapped_index_string_hash (int index_version
, const void *p
)
2951 const unsigned char *str
= (const unsigned char *) p
;
2955 while ((c
= *str
++) != 0)
2957 if (index_version
>= 5)
2959 r
= r
* 67 + c
- 113;
2965 /* Find a slot in the mapped index INDEX for the object named NAME.
2966 If NAME is found, set *VEC_OUT to point to the CU vector in the
2967 constant pool and return 1. If NAME cannot be found, return 0. */
2970 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2971 offset_type
**vec_out
)
2973 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2975 offset_type slot
, step
;
2976 int (*cmp
) (const char *, const char *);
2978 if (current_language
->la_language
== language_cplus
2979 || current_language
->la_language
== language_java
2980 || current_language
->la_language
== language_fortran
2981 || current_language
->la_language
== language_d
)
2983 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2986 if (strchr (name
, '(') != NULL
)
2988 char *without_params
= cp_remove_params (name
);
2990 if (without_params
!= NULL
)
2992 make_cleanup (xfree
, without_params
);
2993 name
= without_params
;
2998 /* Index version 4 did not support case insensitive searches. But the
2999 indices for case insensitive languages are built in lowercase, therefore
3000 simulate our NAME being searched is also lowercased. */
3001 hash
= mapped_index_string_hash ((index
->version
== 4
3002 && case_sensitivity
== case_sensitive_off
3003 ? 5 : index
->version
),
3006 slot
= hash
& (index
->symbol_table_slots
- 1);
3007 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
3008 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3012 /* Convert a slot number to an offset into the table. */
3013 offset_type i
= 2 * slot
;
3015 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
3017 do_cleanups (back_to
);
3021 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
3022 if (!cmp (name
, str
))
3024 *vec_out
= (offset_type
*) (index
->constant_pool
3025 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
3026 do_cleanups (back_to
);
3030 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
3034 /* A helper function that reads the .gdb_index from SECTION and fills
3035 in MAP. FILENAME is the name of the file containing the section;
3036 it is used for error reporting. DEPRECATED_OK is nonzero if it is
3037 ok to use deprecated sections.
3039 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3040 out parameters that are filled in with information about the CU and
3041 TU lists in the section.
3043 Returns 1 if all went well, 0 otherwise. */
3046 read_index_from_section (struct objfile
*objfile
,
3047 const char *filename
,
3049 struct dwarf2_section_info
*section
,
3050 struct mapped_index
*map
,
3051 const gdb_byte
**cu_list
,
3052 offset_type
*cu_list_elements
,
3053 const gdb_byte
**types_list
,
3054 offset_type
*types_list_elements
)
3056 const gdb_byte
*addr
;
3057 offset_type version
;
3058 offset_type
*metadata
;
3061 if (dwarf2_section_empty_p (section
))
3064 /* Older elfutils strip versions could keep the section in the main
3065 executable while splitting it for the separate debug info file. */
3066 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
3069 dwarf2_read_section (objfile
, section
);
3071 addr
= section
->buffer
;
3072 /* Version check. */
3073 version
= MAYBE_SWAP (*(offset_type
*) addr
);
3074 /* Versions earlier than 3 emitted every copy of a psymbol. This
3075 causes the index to behave very poorly for certain requests. Version 3
3076 contained incomplete addrmap. So, it seems better to just ignore such
3080 static int warning_printed
= 0;
3081 if (!warning_printed
)
3083 warning (_("Skipping obsolete .gdb_index section in %s."),
3085 warning_printed
= 1;
3089 /* Index version 4 uses a different hash function than index version
3092 Versions earlier than 6 did not emit psymbols for inlined
3093 functions. Using these files will cause GDB not to be able to
3094 set breakpoints on inlined functions by name, so we ignore these
3095 indices unless the user has done
3096 "set use-deprecated-index-sections on". */
3097 if (version
< 6 && !deprecated_ok
)
3099 static int warning_printed
= 0;
3100 if (!warning_printed
)
3103 Skipping deprecated .gdb_index section in %s.\n\
3104 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3105 to use the section anyway."),
3107 warning_printed
= 1;
3111 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3112 of the TU (for symbols coming from TUs),
3113 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3114 Plus gold-generated indices can have duplicate entries for global symbols,
3115 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3116 These are just performance bugs, and we can't distinguish gdb-generated
3117 indices from gold-generated ones, so issue no warning here. */
3119 /* Indexes with higher version than the one supported by GDB may be no
3120 longer backward compatible. */
3124 map
->version
= version
;
3125 map
->total_size
= section
->size
;
3127 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3130 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3131 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3135 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3136 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3137 - MAYBE_SWAP (metadata
[i
]))
3141 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3142 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
3143 - MAYBE_SWAP (metadata
[i
]));
3146 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
3147 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
3148 - MAYBE_SWAP (metadata
[i
]))
3149 / (2 * sizeof (offset_type
)));
3152 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3158 /* Read the index file. If everything went ok, initialize the "quick"
3159 elements of all the CUs and return 1. Otherwise, return 0. */
3162 dwarf2_read_index (struct objfile
*objfile
)
3164 struct mapped_index local_map
, *map
;
3165 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3166 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3167 struct dwz_file
*dwz
;
3169 if (!read_index_from_section (objfile
, objfile_name (objfile
),
3170 use_deprecated_index_sections
,
3171 &dwarf2_per_objfile
->gdb_index
, &local_map
,
3172 &cu_list
, &cu_list_elements
,
3173 &types_list
, &types_list_elements
))
3176 /* Don't use the index if it's empty. */
3177 if (local_map
.symbol_table_slots
== 0)
3180 /* If there is a .dwz file, read it so we can get its CU list as
3182 dwz
= dwarf2_get_dwz_file ();
3185 struct mapped_index dwz_map
;
3186 const gdb_byte
*dwz_types_ignore
;
3187 offset_type dwz_types_elements_ignore
;
3189 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
3191 &dwz
->gdb_index
, &dwz_map
,
3192 &dwz_list
, &dwz_list_elements
,
3194 &dwz_types_elements_ignore
))
3196 warning (_("could not read '.gdb_index' section from %s; skipping"),
3197 bfd_get_filename (dwz
->dwz_bfd
));
3202 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
3205 if (types_list_elements
)
3207 struct dwarf2_section_info
*section
;
3209 /* We can only handle a single .debug_types when we have an
3211 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3214 section
= VEC_index (dwarf2_section_info_def
,
3215 dwarf2_per_objfile
->types
, 0);
3217 create_signatured_type_table_from_index (objfile
, section
, types_list
,
3218 types_list_elements
);
3221 create_addrmap_from_index (objfile
, &local_map
);
3223 map
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct mapped_index
));
3226 dwarf2_per_objfile
->index_table
= map
;
3227 dwarf2_per_objfile
->using_index
= 1;
3228 dwarf2_per_objfile
->quick_file_names_table
=
3229 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3234 /* A helper for the "quick" functions which sets the global
3235 dwarf2_per_objfile according to OBJFILE. */
3238 dw2_setup (struct objfile
*objfile
)
3240 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
3241 gdb_assert (dwarf2_per_objfile
);
3244 /* die_reader_func for dw2_get_file_names. */
3247 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3248 const gdb_byte
*info_ptr
,
3249 struct die_info
*comp_unit_die
,
3253 struct dwarf2_cu
*cu
= reader
->cu
;
3254 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3255 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3256 struct dwarf2_per_cu_data
*lh_cu
;
3257 struct line_header
*lh
;
3258 struct attribute
*attr
;
3260 const char *name
, *comp_dir
;
3262 struct quick_file_names
*qfn
;
3263 unsigned int line_offset
;
3265 gdb_assert (! this_cu
->is_debug_types
);
3267 /* Our callers never want to match partial units -- instead they
3268 will match the enclosing full CU. */
3269 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3271 this_cu
->v
.quick
->no_file_data
= 1;
3280 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3283 struct quick_file_names find_entry
;
3285 line_offset
= DW_UNSND (attr
);
3287 /* We may have already read in this line header (TU line header sharing).
3288 If we have we're done. */
3289 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3290 find_entry
.hash
.line_offset
.sect_off
= line_offset
;
3291 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3292 &find_entry
, INSERT
);
3295 lh_cu
->v
.quick
->file_names
= *slot
;
3299 lh
= dwarf_decode_line_header (line_offset
, cu
);
3303 lh_cu
->v
.quick
->no_file_data
= 1;
3307 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
3308 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3309 qfn
->hash
.line_offset
.sect_off
= line_offset
;
3310 gdb_assert (slot
!= NULL
);
3313 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
3315 qfn
->num_file_names
= lh
->num_file_names
;
3316 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
3317 lh
->num_file_names
* sizeof (char *));
3318 for (i
= 0; i
< lh
->num_file_names
; ++i
)
3319 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
3320 qfn
->real_names
= NULL
;
3322 free_line_header (lh
);
3324 lh_cu
->v
.quick
->file_names
= qfn
;
3327 /* A helper for the "quick" functions which attempts to read the line
3328 table for THIS_CU. */
3330 static struct quick_file_names
*
3331 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3333 /* This should never be called for TUs. */
3334 gdb_assert (! this_cu
->is_debug_types
);
3335 /* Nor type unit groups. */
3336 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3338 if (this_cu
->v
.quick
->file_names
!= NULL
)
3339 return this_cu
->v
.quick
->file_names
;
3340 /* If we know there is no line data, no point in looking again. */
3341 if (this_cu
->v
.quick
->no_file_data
)
3344 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3346 if (this_cu
->v
.quick
->no_file_data
)
3348 return this_cu
->v
.quick
->file_names
;
3351 /* A helper for the "quick" functions which computes and caches the
3352 real path for a given file name from the line table. */
3355 dw2_get_real_path (struct objfile
*objfile
,
3356 struct quick_file_names
*qfn
, int index
)
3358 if (qfn
->real_names
== NULL
)
3359 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3360 qfn
->num_file_names
, const char *);
3362 if (qfn
->real_names
[index
] == NULL
)
3363 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
3365 return qfn
->real_names
[index
];
3368 static struct symtab
*
3369 dw2_find_last_source_symtab (struct objfile
*objfile
)
3371 struct compunit_symtab
*cust
;
3374 dw2_setup (objfile
);
3375 index
= dwarf2_per_objfile
->n_comp_units
- 1;
3376 cust
= dw2_instantiate_symtab (dw2_get_cutu (index
));
3379 return compunit_primary_filetab (cust
);
3382 /* Traversal function for dw2_forget_cached_source_info. */
3385 dw2_free_cached_file_names (void **slot
, void *info
)
3387 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3389 if (file_data
->real_names
)
3393 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3395 xfree ((void*) file_data
->real_names
[i
]);
3396 file_data
->real_names
[i
] = NULL
;
3404 dw2_forget_cached_source_info (struct objfile
*objfile
)
3406 dw2_setup (objfile
);
3408 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3409 dw2_free_cached_file_names
, NULL
);
3412 /* Helper function for dw2_map_symtabs_matching_filename that expands
3413 the symtabs and calls the iterator. */
3416 dw2_map_expand_apply (struct objfile
*objfile
,
3417 struct dwarf2_per_cu_data
*per_cu
,
3418 const char *name
, const char *real_path
,
3419 int (*callback
) (struct symtab
*, void *),
3422 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3424 /* Don't visit already-expanded CUs. */
3425 if (per_cu
->v
.quick
->compunit_symtab
)
3428 /* This may expand more than one symtab, and we want to iterate over
3430 dw2_instantiate_symtab (per_cu
);
3432 return iterate_over_some_symtabs (name
, real_path
, callback
, data
,
3433 objfile
->compunit_symtabs
, last_made
);
3436 /* Implementation of the map_symtabs_matching_filename method. */
3439 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
3440 const char *real_path
,
3441 int (*callback
) (struct symtab
*, void *),
3445 const char *name_basename
= lbasename (name
);
3447 dw2_setup (objfile
);
3449 /* The rule is CUs specify all the files, including those used by
3450 any TU, so there's no need to scan TUs here. */
3452 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3455 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3456 struct quick_file_names
*file_data
;
3458 /* We only need to look at symtabs not already expanded. */
3459 if (per_cu
->v
.quick
->compunit_symtab
)
3462 file_data
= dw2_get_file_names (per_cu
);
3463 if (file_data
== NULL
)
3466 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3468 const char *this_name
= file_data
->file_names
[j
];
3469 const char *this_real_name
;
3471 if (compare_filenames_for_search (this_name
, name
))
3473 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3479 /* Before we invoke realpath, which can get expensive when many
3480 files are involved, do a quick comparison of the basenames. */
3481 if (! basenames_may_differ
3482 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3485 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3486 if (compare_filenames_for_search (this_real_name
, name
))
3488 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3494 if (real_path
!= NULL
)
3496 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3497 gdb_assert (IS_ABSOLUTE_PATH (name
));
3498 if (this_real_name
!= NULL
3499 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3501 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3513 /* Struct used to manage iterating over all CUs looking for a symbol. */
3515 struct dw2_symtab_iterator
3517 /* The internalized form of .gdb_index. */
3518 struct mapped_index
*index
;
3519 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3520 int want_specific_block
;
3521 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3522 Unused if !WANT_SPECIFIC_BLOCK. */
3524 /* The kind of symbol we're looking for. */
3526 /* The list of CUs from the index entry of the symbol,
3527 or NULL if not found. */
3529 /* The next element in VEC to look at. */
3531 /* The number of elements in VEC, or zero if there is no match. */
3533 /* Have we seen a global version of the symbol?
3534 If so we can ignore all further global instances.
3535 This is to work around gold/15646, inefficient gold-generated
3540 /* Initialize the index symtab iterator ITER.
3541 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3542 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3545 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3546 struct mapped_index
*index
,
3547 int want_specific_block
,
3552 iter
->index
= index
;
3553 iter
->want_specific_block
= want_specific_block
;
3554 iter
->block_index
= block_index
;
3555 iter
->domain
= domain
;
3557 iter
->global_seen
= 0;
3559 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3560 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3568 /* Return the next matching CU or NULL if there are no more. */
3570 static struct dwarf2_per_cu_data
*
3571 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3573 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3575 offset_type cu_index_and_attrs
=
3576 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3577 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3578 struct dwarf2_per_cu_data
*per_cu
;
3579 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3580 /* This value is only valid for index versions >= 7. */
3581 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3582 gdb_index_symbol_kind symbol_kind
=
3583 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3584 /* Only check the symbol attributes if they're present.
3585 Indices prior to version 7 don't record them,
3586 and indices >= 7 may elide them for certain symbols
3587 (gold does this). */
3589 (iter
->index
->version
>= 7
3590 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3592 /* Don't crash on bad data. */
3593 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3594 + dwarf2_per_objfile
->n_type_units
))
3596 complaint (&symfile_complaints
,
3597 _(".gdb_index entry has bad CU index"
3599 objfile_name (dwarf2_per_objfile
->objfile
));
3603 per_cu
= dw2_get_cutu (cu_index
);
3605 /* Skip if already read in. */
3606 if (per_cu
->v
.quick
->compunit_symtab
)
3609 /* Check static vs global. */
3612 if (iter
->want_specific_block
3613 && want_static
!= is_static
)
3615 /* Work around gold/15646. */
3616 if (!is_static
&& iter
->global_seen
)
3619 iter
->global_seen
= 1;
3622 /* Only check the symbol's kind if it has one. */
3625 switch (iter
->domain
)
3628 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3629 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3630 /* Some types are also in VAR_DOMAIN. */
3631 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3635 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3639 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3654 static struct compunit_symtab
*
3655 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3656 const char *name
, domain_enum domain
)
3658 struct compunit_symtab
*stab_best
= NULL
;
3659 struct mapped_index
*index
;
3661 dw2_setup (objfile
);
3663 index
= dwarf2_per_objfile
->index_table
;
3665 /* index is NULL if OBJF_READNOW. */
3668 struct dw2_symtab_iterator iter
;
3669 struct dwarf2_per_cu_data
*per_cu
;
3671 dw2_symtab_iter_init (&iter
, index
, 1, block_index
, domain
, name
);
3673 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3675 struct symbol
*sym
, *with_opaque
= NULL
;
3676 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
);
3677 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3678 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3680 sym
= block_find_symbol (block
, name
, domain
,
3681 block_find_non_opaque_type_preferred
,
3684 /* Some caution must be observed with overloaded functions
3685 and methods, since the index will not contain any overload
3686 information (but NAME might contain it). */
3689 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
3691 if (with_opaque
!= NULL
3692 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
3695 /* Keep looking through other CUs. */
3703 dw2_print_stats (struct objfile
*objfile
)
3705 int i
, total
, count
;
3707 dw2_setup (objfile
);
3708 total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
3710 for (i
= 0; i
< total
; ++i
)
3712 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3714 if (!per_cu
->v
.quick
->compunit_symtab
)
3717 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3718 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3721 /* This dumps minimal information about the index.
3722 It is called via "mt print objfiles".
3723 One use is to verify .gdb_index has been loaded by the
3724 gdb.dwarf2/gdb-index.exp testcase. */
3727 dw2_dump (struct objfile
*objfile
)
3729 dw2_setup (objfile
);
3730 gdb_assert (dwarf2_per_objfile
->using_index
);
3731 printf_filtered (".gdb_index:");
3732 if (dwarf2_per_objfile
->index_table
!= NULL
)
3734 printf_filtered (" version %d\n",
3735 dwarf2_per_objfile
->index_table
->version
);
3738 printf_filtered (" faked for \"readnow\"\n");
3739 printf_filtered ("\n");
3743 dw2_relocate (struct objfile
*objfile
,
3744 const struct section_offsets
*new_offsets
,
3745 const struct section_offsets
*delta
)
3747 /* There's nothing to relocate here. */
3751 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3752 const char *func_name
)
3754 struct mapped_index
*index
;
3756 dw2_setup (objfile
);
3758 index
= dwarf2_per_objfile
->index_table
;
3760 /* index is NULL if OBJF_READNOW. */
3763 struct dw2_symtab_iterator iter
;
3764 struct dwarf2_per_cu_data
*per_cu
;
3766 /* Note: It doesn't matter what we pass for block_index here. */
3767 dw2_symtab_iter_init (&iter
, index
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
3770 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3771 dw2_instantiate_symtab (per_cu
);
3776 dw2_expand_all_symtabs (struct objfile
*objfile
)
3780 dw2_setup (objfile
);
3782 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3783 + dwarf2_per_objfile
->n_type_units
); ++i
)
3785 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3787 dw2_instantiate_symtab (per_cu
);
3792 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3793 const char *fullname
)
3797 dw2_setup (objfile
);
3799 /* We don't need to consider type units here.
3800 This is only called for examining code, e.g. expand_line_sal.
3801 There can be an order of magnitude (or more) more type units
3802 than comp units, and we avoid them if we can. */
3804 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3807 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
3808 struct quick_file_names
*file_data
;
3810 /* We only need to look at symtabs not already expanded. */
3811 if (per_cu
->v
.quick
->compunit_symtab
)
3814 file_data
= dw2_get_file_names (per_cu
);
3815 if (file_data
== NULL
)
3818 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3820 const char *this_fullname
= file_data
->file_names
[j
];
3822 if (filename_cmp (this_fullname
, fullname
) == 0)
3824 dw2_instantiate_symtab (per_cu
);
3832 dw2_map_matching_symbols (struct objfile
*objfile
,
3833 const char * name
, domain_enum domain
,
3835 int (*callback
) (struct block
*,
3836 struct symbol
*, void *),
3837 void *data
, symbol_compare_ftype
*match
,
3838 symbol_compare_ftype
*ordered_compare
)
3840 /* Currently unimplemented; used for Ada. The function can be called if the
3841 current language is Ada for a non-Ada objfile using GNU index. As Ada
3842 does not look for non-Ada symbols this function should just return. */
3846 dw2_expand_symtabs_matching
3847 (struct objfile
*objfile
,
3848 expand_symtabs_file_matcher_ftype
*file_matcher
,
3849 expand_symtabs_symbol_matcher_ftype
*symbol_matcher
,
3850 expand_symtabs_exp_notify_ftype
*expansion_notify
,
3851 enum search_domain kind
,
3856 struct mapped_index
*index
;
3858 dw2_setup (objfile
);
3860 /* index_table is NULL if OBJF_READNOW. */
3861 if (!dwarf2_per_objfile
->index_table
)
3863 index
= dwarf2_per_objfile
->index_table
;
3865 if (file_matcher
!= NULL
)
3867 struct cleanup
*cleanup
;
3868 htab_t visited_found
, visited_not_found
;
3870 visited_found
= htab_create_alloc (10,
3871 htab_hash_pointer
, htab_eq_pointer
,
3872 NULL
, xcalloc
, xfree
);
3873 cleanup
= make_cleanup_htab_delete (visited_found
);
3874 visited_not_found
= htab_create_alloc (10,
3875 htab_hash_pointer
, htab_eq_pointer
,
3876 NULL
, xcalloc
, xfree
);
3877 make_cleanup_htab_delete (visited_not_found
);
3879 /* The rule is CUs specify all the files, including those used by
3880 any TU, so there's no need to scan TUs here. */
3882 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3885 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3886 struct quick_file_names
*file_data
;
3891 per_cu
->v
.quick
->mark
= 0;
3893 /* We only need to look at symtabs not already expanded. */
3894 if (per_cu
->v
.quick
->compunit_symtab
)
3897 file_data
= dw2_get_file_names (per_cu
);
3898 if (file_data
== NULL
)
3901 if (htab_find (visited_not_found
, file_data
) != NULL
)
3903 else if (htab_find (visited_found
, file_data
) != NULL
)
3905 per_cu
->v
.quick
->mark
= 1;
3909 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3911 const char *this_real_name
;
3913 if (file_matcher (file_data
->file_names
[j
], data
, 0))
3915 per_cu
->v
.quick
->mark
= 1;
3919 /* Before we invoke realpath, which can get expensive when many
3920 files are involved, do a quick comparison of the basenames. */
3921 if (!basenames_may_differ
3922 && !file_matcher (lbasename (file_data
->file_names
[j
]),
3926 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3927 if (file_matcher (this_real_name
, data
, 0))
3929 per_cu
->v
.quick
->mark
= 1;
3934 slot
= htab_find_slot (per_cu
->v
.quick
->mark
3936 : visited_not_found
,
3941 do_cleanups (cleanup
);
3944 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
3946 offset_type idx
= 2 * iter
;
3948 offset_type
*vec
, vec_len
, vec_idx
;
3949 int global_seen
= 0;
3953 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
3956 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
3958 if (! (*symbol_matcher
) (name
, data
))
3961 /* The name was matched, now expand corresponding CUs that were
3963 vec
= (offset_type
*) (index
->constant_pool
3964 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
3965 vec_len
= MAYBE_SWAP (vec
[0]);
3966 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
3968 struct dwarf2_per_cu_data
*per_cu
;
3969 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
3970 /* This value is only valid for index versions >= 7. */
3971 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3972 gdb_index_symbol_kind symbol_kind
=
3973 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3974 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3975 /* Only check the symbol attributes if they're present.
3976 Indices prior to version 7 don't record them,
3977 and indices >= 7 may elide them for certain symbols
3978 (gold does this). */
3980 (index
->version
>= 7
3981 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3983 /* Work around gold/15646. */
3986 if (!is_static
&& global_seen
)
3992 /* Only check the symbol's kind if it has one. */
3997 case VARIABLES_DOMAIN
:
3998 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4001 case FUNCTIONS_DOMAIN
:
4002 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4006 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4014 /* Don't crash on bad data. */
4015 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
4016 + dwarf2_per_objfile
->n_type_units
))
4018 complaint (&symfile_complaints
,
4019 _(".gdb_index entry has bad CU index"
4020 " [in module %s]"), objfile_name (objfile
));
4024 per_cu
= dw2_get_cutu (cu_index
);
4025 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4027 int symtab_was_null
=
4028 (per_cu
->v
.quick
->compunit_symtab
== NULL
);
4030 dw2_instantiate_symtab (per_cu
);
4032 if (expansion_notify
!= NULL
4034 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
4036 expansion_notify (per_cu
->v
.quick
->compunit_symtab
,
4044 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4047 static struct compunit_symtab
*
4048 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4053 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4054 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4057 if (cust
->includes
== NULL
)
4060 for (i
= 0; cust
->includes
[i
]; ++i
)
4062 struct compunit_symtab
*s
= cust
->includes
[i
];
4064 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4072 static struct compunit_symtab
*
4073 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
4074 struct bound_minimal_symbol msymbol
,
4076 struct obj_section
*section
,
4079 struct dwarf2_per_cu_data
*data
;
4080 struct compunit_symtab
*result
;
4082 dw2_setup (objfile
);
4084 if (!objfile
->psymtabs_addrmap
)
4087 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
4091 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
4092 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4093 paddress (get_objfile_arch (objfile
), pc
));
4096 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
),
4098 gdb_assert (result
!= NULL
);
4103 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4104 void *data
, int need_fullname
)
4107 struct cleanup
*cleanup
;
4108 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
4109 NULL
, xcalloc
, xfree
);
4111 cleanup
= make_cleanup_htab_delete (visited
);
4112 dw2_setup (objfile
);
4114 /* The rule is CUs specify all the files, including those used by
4115 any TU, so there's no need to scan TUs here.
4116 We can ignore file names coming from already-expanded CUs. */
4118 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4120 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4122 if (per_cu
->v
.quick
->compunit_symtab
)
4124 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
4127 *slot
= per_cu
->v
.quick
->file_names
;
4131 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
4134 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
4135 struct quick_file_names
*file_data
;
4138 /* We only need to look at symtabs not already expanded. */
4139 if (per_cu
->v
.quick
->compunit_symtab
)
4142 file_data
= dw2_get_file_names (per_cu
);
4143 if (file_data
== NULL
)
4146 slot
= htab_find_slot (visited
, file_data
, INSERT
);
4149 /* Already visited. */
4154 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
4156 const char *this_real_name
;
4159 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
4161 this_real_name
= NULL
;
4162 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
4166 do_cleanups (cleanup
);
4170 dw2_has_symbols (struct objfile
*objfile
)
4175 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4178 dw2_find_last_source_symtab
,
4179 dw2_forget_cached_source_info
,
4180 dw2_map_symtabs_matching_filename
,
4185 dw2_expand_symtabs_for_function
,
4186 dw2_expand_all_symtabs
,
4187 dw2_expand_symtabs_with_fullname
,
4188 dw2_map_matching_symbols
,
4189 dw2_expand_symtabs_matching
,
4190 dw2_find_pc_sect_compunit_symtab
,
4191 dw2_map_symbol_filenames
4194 /* Initialize for reading DWARF for this objfile. Return 0 if this
4195 file will use psymtabs, or 1 if using the GNU index. */
4198 dwarf2_initialize_objfile (struct objfile
*objfile
)
4200 /* If we're about to read full symbols, don't bother with the
4201 indices. In this case we also don't care if some other debug
4202 format is making psymtabs, because they are all about to be
4204 if ((objfile
->flags
& OBJF_READNOW
))
4208 dwarf2_per_objfile
->using_index
= 1;
4209 create_all_comp_units (objfile
);
4210 create_all_type_units (objfile
);
4211 dwarf2_per_objfile
->quick_file_names_table
=
4212 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
4214 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
4215 + dwarf2_per_objfile
->n_type_units
); ++i
)
4217 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
4219 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4220 struct dwarf2_per_cu_quick_data
);
4223 /* Return 1 so that gdb sees the "quick" functions. However,
4224 these functions will be no-ops because we will have expanded
4229 if (dwarf2_read_index (objfile
))
4237 /* Build a partial symbol table. */
4240 dwarf2_build_psymtabs (struct objfile
*objfile
)
4243 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
4245 init_psymbol_list (objfile
, 1024);
4250 /* This isn't really ideal: all the data we allocate on the
4251 objfile's obstack is still uselessly kept around. However,
4252 freeing it seems unsafe. */
4253 struct cleanup
*cleanups
= make_cleanup_discard_psymtabs (objfile
);
4255 dwarf2_build_psymtabs_hard (objfile
);
4256 discard_cleanups (cleanups
);
4258 CATCH (except
, RETURN_MASK_ERROR
)
4260 exception_print (gdb_stderr
, except
);
4265 /* Return the total length of the CU described by HEADER. */
4268 get_cu_length (const struct comp_unit_head
*header
)
4270 return header
->initial_length_size
+ header
->length
;
4273 /* Return TRUE if OFFSET is within CU_HEADER. */
4276 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
4278 sect_offset bottom
= { cu_header
->offset
.sect_off
};
4279 sect_offset top
= { cu_header
->offset
.sect_off
+ get_cu_length (cu_header
) };
4281 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
4284 /* Find the base address of the compilation unit for range lists and
4285 location lists. It will normally be specified by DW_AT_low_pc.
4286 In DWARF-3 draft 4, the base address could be overridden by
4287 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4288 compilation units with discontinuous ranges. */
4291 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
4293 struct attribute
*attr
;
4296 cu
->base_address
= 0;
4298 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
4301 cu
->base_address
= attr_value_as_address (attr
);
4306 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
4309 cu
->base_address
= attr_value_as_address (attr
);
4315 /* Read in the comp unit header information from the debug_info at info_ptr.
4316 NOTE: This leaves members offset, first_die_offset to be filled in
4319 static const gdb_byte
*
4320 read_comp_unit_head (struct comp_unit_head
*cu_header
,
4321 const gdb_byte
*info_ptr
, bfd
*abfd
)
4324 unsigned int bytes_read
;
4326 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
4327 cu_header
->initial_length_size
= bytes_read
;
4328 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
4329 info_ptr
+= bytes_read
;
4330 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
4332 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
4334 info_ptr
+= bytes_read
;
4335 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
4337 signed_addr
= bfd_get_sign_extend_vma (abfd
);
4338 if (signed_addr
< 0)
4339 internal_error (__FILE__
, __LINE__
,
4340 _("read_comp_unit_head: dwarf from non elf file"));
4341 cu_header
->signed_addr_p
= signed_addr
;
4346 /* Helper function that returns the proper abbrev section for
4349 static struct dwarf2_section_info
*
4350 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
4352 struct dwarf2_section_info
*abbrev
;
4354 if (this_cu
->is_dwz
)
4355 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
4357 abbrev
= &dwarf2_per_objfile
->abbrev
;
4362 /* Subroutine of read_and_check_comp_unit_head and
4363 read_and_check_type_unit_head to simplify them.
4364 Perform various error checking on the header. */
4367 error_check_comp_unit_head (struct comp_unit_head
*header
,
4368 struct dwarf2_section_info
*section
,
4369 struct dwarf2_section_info
*abbrev_section
)
4371 bfd
*abfd
= get_section_bfd_owner (section
);
4372 const char *filename
= get_section_file_name (section
);
4374 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
4375 error (_("Dwarf Error: wrong version in compilation unit header "
4376 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
4379 if (header
->abbrev_offset
.sect_off
4380 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
4381 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4382 "(offset 0x%lx + 6) [in module %s]"),
4383 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
4386 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4387 avoid potential 32-bit overflow. */
4388 if (((unsigned long) header
->offset
.sect_off
+ get_cu_length (header
))
4390 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4391 "(offset 0x%lx + 0) [in module %s]"),
4392 (long) header
->length
, (long) header
->offset
.sect_off
,
4396 /* Read in a CU/TU header and perform some basic error checking.
4397 The contents of the header are stored in HEADER.
4398 The result is a pointer to the start of the first DIE. */
4400 static const gdb_byte
*
4401 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
4402 struct dwarf2_section_info
*section
,
4403 struct dwarf2_section_info
*abbrev_section
,
4404 const gdb_byte
*info_ptr
,
4405 int is_debug_types_section
)
4407 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4408 bfd
*abfd
= get_section_bfd_owner (section
);
4410 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4412 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4414 /* If we're reading a type unit, skip over the signature and
4415 type_offset fields. */
4416 if (is_debug_types_section
)
4417 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
4419 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4421 error_check_comp_unit_head (header
, section
, abbrev_section
);
4426 /* Read in the types comp unit header information from .debug_types entry at
4427 types_ptr. The result is a pointer to one past the end of the header. */
4429 static const gdb_byte
*
4430 read_and_check_type_unit_head (struct comp_unit_head
*header
,
4431 struct dwarf2_section_info
*section
,
4432 struct dwarf2_section_info
*abbrev_section
,
4433 const gdb_byte
*info_ptr
,
4434 ULONGEST
*signature
,
4435 cu_offset
*type_offset_in_tu
)
4437 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
4438 bfd
*abfd
= get_section_bfd_owner (section
);
4440 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4442 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4444 /* If we're reading a type unit, skip over the signature and
4445 type_offset fields. */
4446 if (signature
!= NULL
)
4447 *signature
= read_8_bytes (abfd
, info_ptr
);
4449 if (type_offset_in_tu
!= NULL
)
4450 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
4451 header
->offset_size
);
4452 info_ptr
+= header
->offset_size
;
4454 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4456 error_check_comp_unit_head (header
, section
, abbrev_section
);
4461 /* Fetch the abbreviation table offset from a comp or type unit header. */
4464 read_abbrev_offset (struct dwarf2_section_info
*section
,
4467 bfd
*abfd
= get_section_bfd_owner (section
);
4468 const gdb_byte
*info_ptr
;
4469 unsigned int length
, initial_length_size
, offset_size
;
4470 sect_offset abbrev_offset
;
4472 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
4473 info_ptr
= section
->buffer
+ offset
.sect_off
;
4474 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
4475 offset_size
= initial_length_size
== 4 ? 4 : 8;
4476 info_ptr
+= initial_length_size
+ 2 /*version*/;
4477 abbrev_offset
.sect_off
= read_offset_1 (abfd
, info_ptr
, offset_size
);
4478 return abbrev_offset
;
4481 /* Allocate a new partial symtab for file named NAME and mark this new
4482 partial symtab as being an include of PST. */
4485 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
4486 struct objfile
*objfile
)
4488 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
4490 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
4492 /* It shares objfile->objfile_obstack. */
4493 subpst
->dirname
= pst
->dirname
;
4496 subpst
->textlow
= 0;
4497 subpst
->texthigh
= 0;
4499 subpst
->dependencies
= (struct partial_symtab
**)
4500 obstack_alloc (&objfile
->objfile_obstack
,
4501 sizeof (struct partial_symtab
*));
4502 subpst
->dependencies
[0] = pst
;
4503 subpst
->number_of_dependencies
= 1;
4505 subpst
->globals_offset
= 0;
4506 subpst
->n_global_syms
= 0;
4507 subpst
->statics_offset
= 0;
4508 subpst
->n_static_syms
= 0;
4509 subpst
->compunit_symtab
= NULL
;
4510 subpst
->read_symtab
= pst
->read_symtab
;
4513 /* No private part is necessary for include psymtabs. This property
4514 can be used to differentiate between such include psymtabs and
4515 the regular ones. */
4516 subpst
->read_symtab_private
= NULL
;
4519 /* Read the Line Number Program data and extract the list of files
4520 included by the source file represented by PST. Build an include
4521 partial symtab for each of these included files. */
4524 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
4525 struct die_info
*die
,
4526 struct partial_symtab
*pst
)
4528 struct line_header
*lh
= NULL
;
4529 struct attribute
*attr
;
4531 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
4533 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
4535 return; /* No linetable, so no includes. */
4537 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4538 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, pst
->textlow
, 1);
4540 free_line_header (lh
);
4544 hash_signatured_type (const void *item
)
4546 const struct signatured_type
*sig_type
= item
;
4548 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4549 return sig_type
->signature
;
4553 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
4555 const struct signatured_type
*lhs
= item_lhs
;
4556 const struct signatured_type
*rhs
= item_rhs
;
4558 return lhs
->signature
== rhs
->signature
;
4561 /* Allocate a hash table for signatured types. */
4564 allocate_signatured_type_table (struct objfile
*objfile
)
4566 return htab_create_alloc_ex (41,
4567 hash_signatured_type
,
4570 &objfile
->objfile_obstack
,
4571 hashtab_obstack_allocate
,
4572 dummy_obstack_deallocate
);
4575 /* A helper function to add a signatured type CU to a table. */
4578 add_signatured_type_cu_to_table (void **slot
, void *datum
)
4580 struct signatured_type
*sigt
= *slot
;
4581 struct signatured_type
***datap
= datum
;
4589 /* Create the hash table of all entries in the .debug_types
4590 (or .debug_types.dwo) section(s).
4591 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4592 otherwise it is NULL.
4594 The result is a pointer to the hash table or NULL if there are no types.
4596 Note: This function processes DWO files only, not DWP files. */
4599 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
4600 VEC (dwarf2_section_info_def
) *types
)
4602 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4603 htab_t types_htab
= NULL
;
4605 struct dwarf2_section_info
*section
;
4606 struct dwarf2_section_info
*abbrev_section
;
4608 if (VEC_empty (dwarf2_section_info_def
, types
))
4611 abbrev_section
= (dwo_file
!= NULL
4612 ? &dwo_file
->sections
.abbrev
4613 : &dwarf2_per_objfile
->abbrev
);
4615 if (dwarf_read_debug
)
4616 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_types%s for %s:\n",
4617 dwo_file
? ".dwo" : "",
4618 get_section_file_name (abbrev_section
));
4621 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
4625 const gdb_byte
*info_ptr
, *end_ptr
;
4627 dwarf2_read_section (objfile
, section
);
4628 info_ptr
= section
->buffer
;
4630 if (info_ptr
== NULL
)
4633 /* We can't set abfd until now because the section may be empty or
4634 not present, in which case the bfd is unknown. */
4635 abfd
= get_section_bfd_owner (section
);
4637 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4638 because we don't need to read any dies: the signature is in the
4641 end_ptr
= info_ptr
+ section
->size
;
4642 while (info_ptr
< end_ptr
)
4645 cu_offset type_offset_in_tu
;
4647 struct signatured_type
*sig_type
;
4648 struct dwo_unit
*dwo_tu
;
4650 const gdb_byte
*ptr
= info_ptr
;
4651 struct comp_unit_head header
;
4652 unsigned int length
;
4654 offset
.sect_off
= ptr
- section
->buffer
;
4656 /* We need to read the type's signature in order to build the hash
4657 table, but we don't need anything else just yet. */
4659 ptr
= read_and_check_type_unit_head (&header
, section
,
4660 abbrev_section
, ptr
,
4661 &signature
, &type_offset_in_tu
);
4663 length
= get_cu_length (&header
);
4665 /* Skip dummy type units. */
4666 if (ptr
>= info_ptr
+ length
4667 || peek_abbrev_code (abfd
, ptr
) == 0)
4673 if (types_htab
== NULL
)
4676 types_htab
= allocate_dwo_unit_table (objfile
);
4678 types_htab
= allocate_signatured_type_table (objfile
);
4684 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4686 dwo_tu
->dwo_file
= dwo_file
;
4687 dwo_tu
->signature
= signature
;
4688 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
4689 dwo_tu
->section
= section
;
4690 dwo_tu
->offset
= offset
;
4691 dwo_tu
->length
= length
;
4695 /* N.B.: type_offset is not usable if this type uses a DWO file.
4696 The real type_offset is in the DWO file. */
4698 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4699 struct signatured_type
);
4700 sig_type
->signature
= signature
;
4701 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
4702 sig_type
->per_cu
.objfile
= objfile
;
4703 sig_type
->per_cu
.is_debug_types
= 1;
4704 sig_type
->per_cu
.section
= section
;
4705 sig_type
->per_cu
.offset
= offset
;
4706 sig_type
->per_cu
.length
= length
;
4709 slot
= htab_find_slot (types_htab
,
4710 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
4712 gdb_assert (slot
!= NULL
);
4715 sect_offset dup_offset
;
4719 const struct dwo_unit
*dup_tu
= *slot
;
4721 dup_offset
= dup_tu
->offset
;
4725 const struct signatured_type
*dup_tu
= *slot
;
4727 dup_offset
= dup_tu
->per_cu
.offset
;
4730 complaint (&symfile_complaints
,
4731 _("debug type entry at offset 0x%x is duplicate to"
4732 " the entry at offset 0x%x, signature %s"),
4733 offset
.sect_off
, dup_offset
.sect_off
,
4734 hex_string (signature
));
4736 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
4738 if (dwarf_read_debug
> 1)
4739 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature %s\n",
4741 hex_string (signature
));
4750 /* Create the hash table of all entries in the .debug_types section,
4751 and initialize all_type_units.
4752 The result is zero if there is an error (e.g. missing .debug_types section),
4753 otherwise non-zero. */
4756 create_all_type_units (struct objfile
*objfile
)
4759 struct signatured_type
**iter
;
4761 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
4762 if (types_htab
== NULL
)
4764 dwarf2_per_objfile
->signatured_types
= NULL
;
4768 dwarf2_per_objfile
->signatured_types
= types_htab
;
4770 dwarf2_per_objfile
->n_type_units
4771 = dwarf2_per_objfile
->n_allocated_type_units
4772 = htab_elements (types_htab
);
4773 dwarf2_per_objfile
->all_type_units
4774 = xmalloc (dwarf2_per_objfile
->n_type_units
4775 * sizeof (struct signatured_type
*));
4776 iter
= &dwarf2_per_objfile
->all_type_units
[0];
4777 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
4778 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
4779 == dwarf2_per_objfile
->n_type_units
);
4784 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
4785 If SLOT is non-NULL, it is the entry to use in the hash table.
4786 Otherwise we find one. */
4788 static struct signatured_type
*
4789 add_type_unit (ULONGEST sig
, void **slot
)
4791 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4792 int n_type_units
= dwarf2_per_objfile
->n_type_units
;
4793 struct signatured_type
*sig_type
;
4795 gdb_assert (n_type_units
<= dwarf2_per_objfile
->n_allocated_type_units
);
4797 if (n_type_units
> dwarf2_per_objfile
->n_allocated_type_units
)
4799 if (dwarf2_per_objfile
->n_allocated_type_units
== 0)
4800 dwarf2_per_objfile
->n_allocated_type_units
= 1;
4801 dwarf2_per_objfile
->n_allocated_type_units
*= 2;
4802 dwarf2_per_objfile
->all_type_units
4803 = xrealloc (dwarf2_per_objfile
->all_type_units
,
4804 dwarf2_per_objfile
->n_allocated_type_units
4805 * sizeof (struct signatured_type
*));
4806 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
4808 dwarf2_per_objfile
->n_type_units
= n_type_units
;
4810 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4811 struct signatured_type
);
4812 dwarf2_per_objfile
->all_type_units
[n_type_units
- 1] = sig_type
;
4813 sig_type
->signature
= sig
;
4814 sig_type
->per_cu
.is_debug_types
= 1;
4815 if (dwarf2_per_objfile
->using_index
)
4817 sig_type
->per_cu
.v
.quick
=
4818 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4819 struct dwarf2_per_cu_quick_data
);
4824 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4827 gdb_assert (*slot
== NULL
);
4829 /* The rest of sig_type must be filled in by the caller. */
4833 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4834 Fill in SIG_ENTRY with DWO_ENTRY. */
4837 fill_in_sig_entry_from_dwo_entry (struct objfile
*objfile
,
4838 struct signatured_type
*sig_entry
,
4839 struct dwo_unit
*dwo_entry
)
4841 /* Make sure we're not clobbering something we don't expect to. */
4842 gdb_assert (! sig_entry
->per_cu
.queued
);
4843 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
4844 if (dwarf2_per_objfile
->using_index
)
4846 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
4847 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
4850 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
4851 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
4852 gdb_assert (sig_entry
->type_offset_in_section
.sect_off
== 0);
4853 gdb_assert (sig_entry
->type_unit_group
== NULL
);
4854 gdb_assert (sig_entry
->dwo_unit
== NULL
);
4856 sig_entry
->per_cu
.section
= dwo_entry
->section
;
4857 sig_entry
->per_cu
.offset
= dwo_entry
->offset
;
4858 sig_entry
->per_cu
.length
= dwo_entry
->length
;
4859 sig_entry
->per_cu
.reading_dwo_directly
= 1;
4860 sig_entry
->per_cu
.objfile
= objfile
;
4861 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
4862 sig_entry
->dwo_unit
= dwo_entry
;
4865 /* Subroutine of lookup_signatured_type.
4866 If we haven't read the TU yet, create the signatured_type data structure
4867 for a TU to be read in directly from a DWO file, bypassing the stub.
4868 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4869 using .gdb_index, then when reading a CU we want to stay in the DWO file
4870 containing that CU. Otherwise we could end up reading several other DWO
4871 files (due to comdat folding) to process the transitive closure of all the
4872 mentioned TUs, and that can be slow. The current DWO file will have every
4873 type signature that it needs.
4874 We only do this for .gdb_index because in the psymtab case we already have
4875 to read all the DWOs to build the type unit groups. */
4877 static struct signatured_type
*
4878 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4880 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4881 struct dwo_file
*dwo_file
;
4882 struct dwo_unit find_dwo_entry
, *dwo_entry
;
4883 struct signatured_type find_sig_entry
, *sig_entry
;
4886 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4888 /* If TU skeletons have been removed then we may not have read in any
4890 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4892 dwarf2_per_objfile
->signatured_types
4893 = allocate_signatured_type_table (objfile
);
4896 /* We only ever need to read in one copy of a signatured type.
4897 Use the global signatured_types array to do our own comdat-folding
4898 of types. If this is the first time we're reading this TU, and
4899 the TU has an entry in .gdb_index, replace the recorded data from
4900 .gdb_index with this TU. */
4902 find_sig_entry
.signature
= sig
;
4903 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4904 &find_sig_entry
, INSERT
);
4907 /* We can get here with the TU already read, *or* in the process of being
4908 read. Don't reassign the global entry to point to this DWO if that's
4909 the case. Also note that if the TU is already being read, it may not
4910 have come from a DWO, the program may be a mix of Fission-compiled
4911 code and non-Fission-compiled code. */
4913 /* Have we already tried to read this TU?
4914 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4915 needn't exist in the global table yet). */
4916 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
4919 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4920 dwo_unit of the TU itself. */
4921 dwo_file
= cu
->dwo_unit
->dwo_file
;
4923 /* Ok, this is the first time we're reading this TU. */
4924 if (dwo_file
->tus
== NULL
)
4926 find_dwo_entry
.signature
= sig
;
4927 dwo_entry
= htab_find (dwo_file
->tus
, &find_dwo_entry
);
4928 if (dwo_entry
== NULL
)
4931 /* If the global table doesn't have an entry for this TU, add one. */
4932 if (sig_entry
== NULL
)
4933 sig_entry
= add_type_unit (sig
, slot
);
4935 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4936 sig_entry
->per_cu
.tu_read
= 1;
4940 /* Subroutine of lookup_signatured_type.
4941 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4942 then try the DWP file. If the TU stub (skeleton) has been removed then
4943 it won't be in .gdb_index. */
4945 static struct signatured_type
*
4946 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4948 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4949 struct dwp_file
*dwp_file
= get_dwp_file ();
4950 struct dwo_unit
*dwo_entry
;
4951 struct signatured_type find_sig_entry
, *sig_entry
;
4954 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
4955 gdb_assert (dwp_file
!= NULL
);
4957 /* If TU skeletons have been removed then we may not have read in any
4959 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4961 dwarf2_per_objfile
->signatured_types
4962 = allocate_signatured_type_table (objfile
);
4965 find_sig_entry
.signature
= sig
;
4966 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
4967 &find_sig_entry
, INSERT
);
4970 /* Have we already tried to read this TU?
4971 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4972 needn't exist in the global table yet). */
4973 if (sig_entry
!= NULL
)
4976 if (dwp_file
->tus
== NULL
)
4978 dwo_entry
= lookup_dwo_unit_in_dwp (dwp_file
, NULL
,
4979 sig
, 1 /* is_debug_types */);
4980 if (dwo_entry
== NULL
)
4983 sig_entry
= add_type_unit (sig
, slot
);
4984 fill_in_sig_entry_from_dwo_entry (objfile
, sig_entry
, dwo_entry
);
4989 /* Lookup a signature based type for DW_FORM_ref_sig8.
4990 Returns NULL if signature SIG is not present in the table.
4991 It is up to the caller to complain about this. */
4993 static struct signatured_type
*
4994 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
4997 && dwarf2_per_objfile
->using_index
)
4999 /* We're in a DWO/DWP file, and we're using .gdb_index.
5000 These cases require special processing. */
5001 if (get_dwp_file () == NULL
)
5002 return lookup_dwo_signatured_type (cu
, sig
);
5004 return lookup_dwp_signatured_type (cu
, sig
);
5008 struct signatured_type find_entry
, *entry
;
5010 if (dwarf2_per_objfile
->signatured_types
== NULL
)
5012 find_entry
.signature
= sig
;
5013 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
5018 /* Low level DIE reading support. */
5020 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
5023 init_cu_die_reader (struct die_reader_specs
*reader
,
5024 struct dwarf2_cu
*cu
,
5025 struct dwarf2_section_info
*section
,
5026 struct dwo_file
*dwo_file
)
5028 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
5029 reader
->abfd
= get_section_bfd_owner (section
);
5031 reader
->dwo_file
= dwo_file
;
5032 reader
->die_section
= section
;
5033 reader
->buffer
= section
->buffer
;
5034 reader
->buffer_end
= section
->buffer
+ section
->size
;
5035 reader
->comp_dir
= NULL
;
5038 /* Subroutine of init_cutu_and_read_dies to simplify it.
5039 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
5040 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
5043 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
5044 from it to the DIE in the DWO. If NULL we are skipping the stub.
5045 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
5046 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
5047 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
5048 STUB_COMP_DIR may be non-NULL.
5049 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
5050 are filled in with the info of the DIE from the DWO file.
5051 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
5052 provided an abbrev table to use.
5053 The result is non-zero if a valid (non-dummy) DIE was found. */
5056 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
5057 struct dwo_unit
*dwo_unit
,
5058 int abbrev_table_provided
,
5059 struct die_info
*stub_comp_unit_die
,
5060 const char *stub_comp_dir
,
5061 struct die_reader_specs
*result_reader
,
5062 const gdb_byte
**result_info_ptr
,
5063 struct die_info
**result_comp_unit_die
,
5064 int *result_has_children
)
5066 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5067 struct dwarf2_cu
*cu
= this_cu
->cu
;
5068 struct dwarf2_section_info
*section
;
5070 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5071 ULONGEST signature
; /* Or dwo_id. */
5072 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
5073 int i
,num_extra_attrs
;
5074 struct dwarf2_section_info
*dwo_abbrev_section
;
5075 struct attribute
*attr
;
5076 struct die_info
*comp_unit_die
;
5078 /* At most one of these may be provided. */
5079 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
5081 /* These attributes aren't processed until later:
5082 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
5083 DW_AT_comp_dir is used now, to find the DWO file, but it is also
5084 referenced later. However, these attributes are found in the stub
5085 which we won't have later. In order to not impose this complication
5086 on the rest of the code, we read them here and copy them to the
5095 if (stub_comp_unit_die
!= NULL
)
5097 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5099 if (! this_cu
->is_debug_types
)
5100 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
5101 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
5102 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
5103 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
5104 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
5106 /* There should be a DW_AT_addr_base attribute here (if needed).
5107 We need the value before we can process DW_FORM_GNU_addr_index. */
5109 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
5111 cu
->addr_base
= DW_UNSND (attr
);
5113 /* There should be a DW_AT_ranges_base attribute here (if needed).
5114 We need the value before we can process DW_AT_ranges. */
5115 cu
->ranges_base
= 0;
5116 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
5118 cu
->ranges_base
= DW_UNSND (attr
);
5120 else if (stub_comp_dir
!= NULL
)
5122 /* Reconstruct the comp_dir attribute to simplify the code below. */
5123 comp_dir
= (struct attribute
*)
5124 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (*comp_dir
));
5125 comp_dir
->name
= DW_AT_comp_dir
;
5126 comp_dir
->form
= DW_FORM_string
;
5127 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
5128 DW_STRING (comp_dir
) = stub_comp_dir
;
5131 /* Set up for reading the DWO CU/TU. */
5132 cu
->dwo_unit
= dwo_unit
;
5133 section
= dwo_unit
->section
;
5134 dwarf2_read_section (objfile
, section
);
5135 abfd
= get_section_bfd_owner (section
);
5136 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
5137 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
5138 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
5140 if (this_cu
->is_debug_types
)
5142 ULONGEST header_signature
;
5143 cu_offset type_offset_in_tu
;
5144 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
5146 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5150 &type_offset_in_tu
);
5151 /* This is not an assert because it can be caused by bad debug info. */
5152 if (sig_type
->signature
!= header_signature
)
5154 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5155 " TU at offset 0x%x [in module %s]"),
5156 hex_string (sig_type
->signature
),
5157 hex_string (header_signature
),
5158 dwo_unit
->offset
.sect_off
,
5159 bfd_get_filename (abfd
));
5161 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5162 /* For DWOs coming from DWP files, we don't know the CU length
5163 nor the type's offset in the TU until now. */
5164 dwo_unit
->length
= get_cu_length (&cu
->header
);
5165 dwo_unit
->type_offset_in_tu
= type_offset_in_tu
;
5167 /* Establish the type offset that can be used to lookup the type.
5168 For DWO files, we don't know it until now. */
5169 sig_type
->type_offset_in_section
.sect_off
=
5170 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
5174 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5177 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5178 /* For DWOs coming from DWP files, we don't know the CU length
5180 dwo_unit
->length
= get_cu_length (&cu
->header
);
5183 /* Replace the CU's original abbrev table with the DWO's.
5184 Reminder: We can't read the abbrev table until we've read the header. */
5185 if (abbrev_table_provided
)
5187 /* Don't free the provided abbrev table, the caller of
5188 init_cutu_and_read_dies owns it. */
5189 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5190 /* Ensure the DWO abbrev table gets freed. */
5191 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5195 dwarf2_free_abbrev_table (cu
);
5196 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
5197 /* Leave any existing abbrev table cleanup as is. */
5200 /* Read in the die, but leave space to copy over the attributes
5201 from the stub. This has the benefit of simplifying the rest of
5202 the code - all the work to maintain the illusion of a single
5203 DW_TAG_{compile,type}_unit DIE is done here. */
5204 num_extra_attrs
= ((stmt_list
!= NULL
)
5208 + (comp_dir
!= NULL
));
5209 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
5210 result_has_children
, num_extra_attrs
);
5212 /* Copy over the attributes from the stub to the DIE we just read in. */
5213 comp_unit_die
= *result_comp_unit_die
;
5214 i
= comp_unit_die
->num_attrs
;
5215 if (stmt_list
!= NULL
)
5216 comp_unit_die
->attrs
[i
++] = *stmt_list
;
5218 comp_unit_die
->attrs
[i
++] = *low_pc
;
5219 if (high_pc
!= NULL
)
5220 comp_unit_die
->attrs
[i
++] = *high_pc
;
5222 comp_unit_die
->attrs
[i
++] = *ranges
;
5223 if (comp_dir
!= NULL
)
5224 comp_unit_die
->attrs
[i
++] = *comp_dir
;
5225 comp_unit_die
->num_attrs
+= num_extra_attrs
;
5227 if (dwarf_die_debug
)
5229 fprintf_unfiltered (gdb_stdlog
,
5230 "Read die from %s@0x%x of %s:\n",
5231 get_section_name (section
),
5232 (unsigned) (begin_info_ptr
- section
->buffer
),
5233 bfd_get_filename (abfd
));
5234 dump_die (comp_unit_die
, dwarf_die_debug
);
5237 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5238 TUs by skipping the stub and going directly to the entry in the DWO file.
5239 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5240 to get it via circuitous means. Blech. */
5241 if (comp_dir
!= NULL
)
5242 result_reader
->comp_dir
= DW_STRING (comp_dir
);
5244 /* Skip dummy compilation units. */
5245 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
5246 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5249 *result_info_ptr
= info_ptr
;
5253 /* Subroutine of init_cutu_and_read_dies to simplify it.
5254 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5255 Returns NULL if the specified DWO unit cannot be found. */
5257 static struct dwo_unit
*
5258 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
5259 struct die_info
*comp_unit_die
)
5261 struct dwarf2_cu
*cu
= this_cu
->cu
;
5262 struct attribute
*attr
;
5264 struct dwo_unit
*dwo_unit
;
5265 const char *comp_dir
, *dwo_name
;
5267 gdb_assert (cu
!= NULL
);
5269 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5270 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5271 gdb_assert (attr
!= NULL
);
5272 dwo_name
= DW_STRING (attr
);
5274 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5276 comp_dir
= DW_STRING (attr
);
5278 if (this_cu
->is_debug_types
)
5280 struct signatured_type
*sig_type
;
5282 /* Since this_cu is the first member of struct signatured_type,
5283 we can go from a pointer to one to a pointer to the other. */
5284 sig_type
= (struct signatured_type
*) this_cu
;
5285 signature
= sig_type
->signature
;
5286 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
5290 struct attribute
*attr
;
5292 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
5294 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5296 dwo_name
, objfile_name (this_cu
->objfile
));
5297 signature
= DW_UNSND (attr
);
5298 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
5305 /* Subroutine of init_cutu_and_read_dies to simplify it.
5306 See it for a description of the parameters.
5307 Read a TU directly from a DWO file, bypassing the stub.
5309 Note: This function could be a little bit simpler if we shared cleanups
5310 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
5311 to do, so we keep this function self-contained. Or we could move this
5312 into our caller, but it's complex enough already. */
5315 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
5316 int use_existing_cu
, int keep
,
5317 die_reader_func_ftype
*die_reader_func
,
5320 struct dwarf2_cu
*cu
;
5321 struct signatured_type
*sig_type
;
5322 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5323 struct die_reader_specs reader
;
5324 const gdb_byte
*info_ptr
;
5325 struct die_info
*comp_unit_die
;
5328 /* Verify we can do the following downcast, and that we have the
5330 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
5331 sig_type
= (struct signatured_type
*) this_cu
;
5332 gdb_assert (sig_type
->dwo_unit
!= NULL
);
5334 cleanups
= make_cleanup (null_cleanup
, NULL
);
5336 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5338 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
5340 /* There's no need to do the rereading_dwo_cu handling that
5341 init_cutu_and_read_dies does since we don't read the stub. */
5345 /* If !use_existing_cu, this_cu->cu must be NULL. */
5346 gdb_assert (this_cu
->cu
== NULL
);
5347 cu
= xmalloc (sizeof (*cu
));
5348 init_one_comp_unit (cu
, this_cu
);
5349 /* If an error occurs while loading, release our storage. */
5350 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5353 /* A future optimization, if needed, would be to use an existing
5354 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
5355 could share abbrev tables. */
5357 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
5358 0 /* abbrev_table_provided */,
5359 NULL
/* stub_comp_unit_die */,
5360 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
5362 &comp_unit_die
, &has_children
) == 0)
5365 do_cleanups (cleanups
);
5369 /* All the "real" work is done here. */
5370 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5372 /* This duplicates the code in init_cutu_and_read_dies,
5373 but the alternative is making the latter more complex.
5374 This function is only for the special case of using DWO files directly:
5375 no point in overly complicating the general case just to handle this. */
5376 if (free_cu_cleanup
!= NULL
)
5380 /* We've successfully allocated this compilation unit. Let our
5381 caller clean it up when finished with it. */
5382 discard_cleanups (free_cu_cleanup
);
5384 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5385 So we have to manually free the abbrev table. */
5386 dwarf2_free_abbrev_table (cu
);
5388 /* Link this CU into read_in_chain. */
5389 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5390 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5393 do_cleanups (free_cu_cleanup
);
5396 do_cleanups (cleanups
);
5399 /* Initialize a CU (or TU) and read its DIEs.
5400 If the CU defers to a DWO file, read the DWO file as well.
5402 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5403 Otherwise the table specified in the comp unit header is read in and used.
5404 This is an optimization for when we already have the abbrev table.
5406 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5407 Otherwise, a new CU is allocated with xmalloc.
5409 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5410 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5412 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5413 linker) then DIE_READER_FUNC will not get called. */
5416 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
5417 struct abbrev_table
*abbrev_table
,
5418 int use_existing_cu
, int keep
,
5419 die_reader_func_ftype
*die_reader_func
,
5422 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5423 struct dwarf2_section_info
*section
= this_cu
->section
;
5424 bfd
*abfd
= get_section_bfd_owner (section
);
5425 struct dwarf2_cu
*cu
;
5426 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5427 struct die_reader_specs reader
;
5428 struct die_info
*comp_unit_die
;
5430 struct attribute
*attr
;
5431 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
5432 struct signatured_type
*sig_type
= NULL
;
5433 struct dwarf2_section_info
*abbrev_section
;
5434 /* Non-zero if CU currently points to a DWO file and we need to
5435 reread it. When this happens we need to reread the skeleton die
5436 before we can reread the DWO file (this only applies to CUs, not TUs). */
5437 int rereading_dwo_cu
= 0;
5439 if (dwarf_die_debug
)
5440 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5441 this_cu
->is_debug_types
? "type" : "comp",
5442 this_cu
->offset
.sect_off
);
5444 if (use_existing_cu
)
5447 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5448 file (instead of going through the stub), short-circuit all of this. */
5449 if (this_cu
->reading_dwo_directly
)
5451 /* Narrow down the scope of possibilities to have to understand. */
5452 gdb_assert (this_cu
->is_debug_types
);
5453 gdb_assert (abbrev_table
== NULL
);
5454 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
5455 die_reader_func
, data
);
5459 cleanups
= make_cleanup (null_cleanup
, NULL
);
5461 /* This is cheap if the section is already read in. */
5462 dwarf2_read_section (objfile
, section
);
5464 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5466 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
5468 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
5471 /* If this CU is from a DWO file we need to start over, we need to
5472 refetch the attributes from the skeleton CU.
5473 This could be optimized by retrieving those attributes from when we
5474 were here the first time: the previous comp_unit_die was stored in
5475 comp_unit_obstack. But there's no data yet that we need this
5477 if (cu
->dwo_unit
!= NULL
)
5478 rereading_dwo_cu
= 1;
5482 /* If !use_existing_cu, this_cu->cu must be NULL. */
5483 gdb_assert (this_cu
->cu
== NULL
);
5484 cu
= xmalloc (sizeof (*cu
));
5485 init_one_comp_unit (cu
, this_cu
);
5486 /* If an error occurs while loading, release our storage. */
5487 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
5490 /* Get the header. */
5491 if (cu
->header
.first_die_offset
.cu_off
!= 0 && ! rereading_dwo_cu
)
5493 /* We already have the header, there's no need to read it in again. */
5494 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
5498 if (this_cu
->is_debug_types
)
5501 cu_offset type_offset_in_tu
;
5503 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
5504 abbrev_section
, info_ptr
,
5506 &type_offset_in_tu
);
5508 /* Since per_cu is the first member of struct signatured_type,
5509 we can go from a pointer to one to a pointer to the other. */
5510 sig_type
= (struct signatured_type
*) this_cu
;
5511 gdb_assert (sig_type
->signature
== signature
);
5512 gdb_assert (sig_type
->type_offset_in_tu
.cu_off
5513 == type_offset_in_tu
.cu_off
);
5514 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5516 /* LENGTH has not been set yet for type units if we're
5517 using .gdb_index. */
5518 this_cu
->length
= get_cu_length (&cu
->header
);
5520 /* Establish the type offset that can be used to lookup the type. */
5521 sig_type
->type_offset_in_section
.sect_off
=
5522 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
5526 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
5530 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
5531 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
5535 /* Skip dummy compilation units. */
5536 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5537 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5539 do_cleanups (cleanups
);
5543 /* If we don't have them yet, read the abbrevs for this compilation unit.
5544 And if we need to read them now, make sure they're freed when we're
5545 done. Note that it's important that if the CU had an abbrev table
5546 on entry we don't free it when we're done: Somewhere up the call stack
5547 it may be in use. */
5548 if (abbrev_table
!= NULL
)
5550 gdb_assert (cu
->abbrev_table
== NULL
);
5551 gdb_assert (cu
->header
.abbrev_offset
.sect_off
5552 == abbrev_table
->offset
.sect_off
);
5553 cu
->abbrev_table
= abbrev_table
;
5555 else if (cu
->abbrev_table
== NULL
)
5557 dwarf2_read_abbrevs (cu
, abbrev_section
);
5558 make_cleanup (dwarf2_free_abbrev_table
, cu
);
5560 else if (rereading_dwo_cu
)
5562 dwarf2_free_abbrev_table (cu
);
5563 dwarf2_read_abbrevs (cu
, abbrev_section
);
5566 /* Read the top level CU/TU die. */
5567 init_cu_die_reader (&reader
, cu
, section
, NULL
);
5568 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5570 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5572 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5573 DWO CU, that this test will fail (the attribute will not be present). */
5574 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
5577 struct dwo_unit
*dwo_unit
;
5578 struct die_info
*dwo_comp_unit_die
;
5582 complaint (&symfile_complaints
,
5583 _("compilation unit with DW_AT_GNU_dwo_name"
5584 " has children (offset 0x%x) [in module %s]"),
5585 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
5587 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
5588 if (dwo_unit
!= NULL
)
5590 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
5591 abbrev_table
!= NULL
,
5592 comp_unit_die
, NULL
,
5594 &dwo_comp_unit_die
, &has_children
) == 0)
5597 do_cleanups (cleanups
);
5600 comp_unit_die
= dwo_comp_unit_die
;
5604 /* Yikes, we couldn't find the rest of the DIE, we only have
5605 the stub. A complaint has already been logged. There's
5606 not much more we can do except pass on the stub DIE to
5607 die_reader_func. We don't want to throw an error on bad
5612 /* All of the above is setup for this call. Yikes. */
5613 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5615 /* Done, clean up. */
5616 if (free_cu_cleanup
!= NULL
)
5620 /* We've successfully allocated this compilation unit. Let our
5621 caller clean it up when finished with it. */
5622 discard_cleanups (free_cu_cleanup
);
5624 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5625 So we have to manually free the abbrev table. */
5626 dwarf2_free_abbrev_table (cu
);
5628 /* Link this CU into read_in_chain. */
5629 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5630 dwarf2_per_objfile
->read_in_chain
= this_cu
;
5633 do_cleanups (free_cu_cleanup
);
5636 do_cleanups (cleanups
);
5639 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5640 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5641 to have already done the lookup to find the DWO file).
5643 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5644 THIS_CU->is_debug_types, but nothing else.
5646 We fill in THIS_CU->length.
5648 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5649 linker) then DIE_READER_FUNC will not get called.
5651 THIS_CU->cu is always freed when done.
5652 This is done in order to not leave THIS_CU->cu in a state where we have
5653 to care whether it refers to the "main" CU or the DWO CU. */
5656 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
5657 struct dwo_file
*dwo_file
,
5658 die_reader_func_ftype
*die_reader_func
,
5661 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5662 struct dwarf2_section_info
*section
= this_cu
->section
;
5663 bfd
*abfd
= get_section_bfd_owner (section
);
5664 struct dwarf2_section_info
*abbrev_section
;
5665 struct dwarf2_cu cu
;
5666 const gdb_byte
*begin_info_ptr
, *info_ptr
;
5667 struct die_reader_specs reader
;
5668 struct cleanup
*cleanups
;
5669 struct die_info
*comp_unit_die
;
5672 if (dwarf_die_debug
)
5673 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
5674 this_cu
->is_debug_types
? "type" : "comp",
5675 this_cu
->offset
.sect_off
);
5677 gdb_assert (this_cu
->cu
== NULL
);
5679 abbrev_section
= (dwo_file
!= NULL
5680 ? &dwo_file
->sections
.abbrev
5681 : get_abbrev_section_for_cu (this_cu
));
5683 /* This is cheap if the section is already read in. */
5684 dwarf2_read_section (objfile
, section
);
5686 init_one_comp_unit (&cu
, this_cu
);
5688 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
5690 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
5691 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
5692 abbrev_section
, info_ptr
,
5693 this_cu
->is_debug_types
);
5695 this_cu
->length
= get_cu_length (&cu
.header
);
5697 /* Skip dummy compilation units. */
5698 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
5699 || peek_abbrev_code (abfd
, info_ptr
) == 0)
5701 do_cleanups (cleanups
);
5705 dwarf2_read_abbrevs (&cu
, abbrev_section
);
5706 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
5708 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
5709 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
5711 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
5713 do_cleanups (cleanups
);
5716 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5717 does not lookup the specified DWO file.
5718 This cannot be used to read DWO files.
5720 THIS_CU->cu is always freed when done.
5721 This is done in order to not leave THIS_CU->cu in a state where we have
5722 to care whether it refers to the "main" CU or the DWO CU.
5723 We can revisit this if the data shows there's a performance issue. */
5726 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
5727 die_reader_func_ftype
*die_reader_func
,
5730 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
5733 /* Type Unit Groups.
5735 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5736 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5737 so that all types coming from the same compilation (.o file) are grouped
5738 together. A future step could be to put the types in the same symtab as
5739 the CU the types ultimately came from. */
5742 hash_type_unit_group (const void *item
)
5744 const struct type_unit_group
*tu_group
= item
;
5746 return hash_stmt_list_entry (&tu_group
->hash
);
5750 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
5752 const struct type_unit_group
*lhs
= item_lhs
;
5753 const struct type_unit_group
*rhs
= item_rhs
;
5755 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
5758 /* Allocate a hash table for type unit groups. */
5761 allocate_type_unit_groups_table (void)
5763 return htab_create_alloc_ex (3,
5764 hash_type_unit_group
,
5767 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
5768 hashtab_obstack_allocate
,
5769 dummy_obstack_deallocate
);
5772 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5773 partial symtabs. We combine several TUs per psymtab to not let the size
5774 of any one psymtab grow too big. */
5775 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5776 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5778 /* Helper routine for get_type_unit_group.
5779 Create the type_unit_group object used to hold one or more TUs. */
5781 static struct type_unit_group
*
5782 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
5784 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5785 struct dwarf2_per_cu_data
*per_cu
;
5786 struct type_unit_group
*tu_group
;
5788 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5789 struct type_unit_group
);
5790 per_cu
= &tu_group
->per_cu
;
5791 per_cu
->objfile
= objfile
;
5793 if (dwarf2_per_objfile
->using_index
)
5795 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5796 struct dwarf2_per_cu_quick_data
);
5800 unsigned int line_offset
= line_offset_struct
.sect_off
;
5801 struct partial_symtab
*pst
;
5804 /* Give the symtab a useful name for debug purposes. */
5805 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
5806 name
= xstrprintf ("<type_units_%d>",
5807 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
5809 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
5811 pst
= create_partial_symtab (per_cu
, name
);
5817 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
5818 tu_group
->hash
.line_offset
= line_offset_struct
;
5823 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5824 STMT_LIST is a DW_AT_stmt_list attribute. */
5826 static struct type_unit_group
*
5827 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
5829 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5830 struct type_unit_group
*tu_group
;
5832 unsigned int line_offset
;
5833 struct type_unit_group type_unit_group_for_lookup
;
5835 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
5837 dwarf2_per_objfile
->type_unit_groups
=
5838 allocate_type_unit_groups_table ();
5841 /* Do we need to create a new group, or can we use an existing one? */
5845 line_offset
= DW_UNSND (stmt_list
);
5846 ++tu_stats
->nr_symtab_sharers
;
5850 /* Ugh, no stmt_list. Rare, but we have to handle it.
5851 We can do various things here like create one group per TU or
5852 spread them over multiple groups to split up the expansion work.
5853 To avoid worst case scenarios (too many groups or too large groups)
5854 we, umm, group them in bunches. */
5855 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5856 | (tu_stats
->nr_stmt_less_type_units
5857 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
5858 ++tu_stats
->nr_stmt_less_type_units
;
5861 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
5862 type_unit_group_for_lookup
.hash
.line_offset
.sect_off
= line_offset
;
5863 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
5864 &type_unit_group_for_lookup
, INSERT
);
5868 gdb_assert (tu_group
!= NULL
);
5872 sect_offset line_offset_struct
;
5874 line_offset_struct
.sect_off
= line_offset
;
5875 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
5877 ++tu_stats
->nr_symtabs
;
5883 /* Partial symbol tables. */
5885 /* Create a psymtab named NAME and assign it to PER_CU.
5887 The caller must fill in the following details:
5888 dirname, textlow, texthigh. */
5890 static struct partial_symtab
*
5891 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
5893 struct objfile
*objfile
= per_cu
->objfile
;
5894 struct partial_symtab
*pst
;
5896 pst
= start_psymtab_common (objfile
, name
, 0,
5897 objfile
->global_psymbols
.next
,
5898 objfile
->static_psymbols
.next
);
5900 pst
->psymtabs_addrmap_supported
= 1;
5902 /* This is the glue that links PST into GDB's symbol API. */
5903 pst
->read_symtab_private
= per_cu
;
5904 pst
->read_symtab
= dwarf2_read_symtab
;
5905 per_cu
->v
.psymtab
= pst
;
5910 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5913 struct process_psymtab_comp_unit_data
5915 /* True if we are reading a DW_TAG_partial_unit. */
5917 int want_partial_unit
;
5919 /* The "pretend" language that is used if the CU doesn't declare a
5922 enum language pretend_language
;
5925 /* die_reader_func for process_psymtab_comp_unit. */
5928 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
5929 const gdb_byte
*info_ptr
,
5930 struct die_info
*comp_unit_die
,
5934 struct dwarf2_cu
*cu
= reader
->cu
;
5935 struct objfile
*objfile
= cu
->objfile
;
5936 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5937 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
5938 struct attribute
*attr
;
5940 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
5941 struct partial_symtab
*pst
;
5943 const char *filename
;
5944 struct process_psymtab_comp_unit_data
*info
= data
;
5946 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
5949 gdb_assert (! per_cu
->is_debug_types
);
5951 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
5953 cu
->list_in_scope
= &file_symbols
;
5955 /* Allocate a new partial symbol table structure. */
5956 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
5957 if (attr
== NULL
|| !DW_STRING (attr
))
5960 filename
= DW_STRING (attr
);
5962 pst
= create_partial_symtab (per_cu
, filename
);
5964 /* This must be done before calling dwarf2_build_include_psymtabs. */
5965 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5967 pst
->dirname
= DW_STRING (attr
);
5969 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5971 dwarf2_find_base_address (comp_unit_die
, cu
);
5973 /* Possibly set the default values of LOWPC and HIGHPC from
5975 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
5976 &best_highpc
, cu
, pst
);
5977 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
5978 /* Store the contiguous range if it is not empty; it can be empty for
5979 CUs with no code. */
5980 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5981 gdbarch_adjust_dwarf2_addr (gdbarch
,
5982 best_lowpc
+ baseaddr
),
5983 gdbarch_adjust_dwarf2_addr (gdbarch
,
5984 best_highpc
+ baseaddr
) - 1,
5987 /* Check if comp unit has_children.
5988 If so, read the rest of the partial symbols from this comp unit.
5989 If not, there's no more debug_info for this comp unit. */
5992 struct partial_die_info
*first_die
;
5993 CORE_ADDR lowpc
, highpc
;
5995 lowpc
= ((CORE_ADDR
) -1);
5996 highpc
= ((CORE_ADDR
) 0);
5998 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6000 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
6003 /* If we didn't find a lowpc, set it to highpc to avoid
6004 complaints from `maint check'. */
6005 if (lowpc
== ((CORE_ADDR
) -1))
6008 /* If the compilation unit didn't have an explicit address range,
6009 then use the information extracted from its child dies. */
6013 best_highpc
= highpc
;
6016 pst
->textlow
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
);
6017 pst
->texthigh
= gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
);
6019 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6020 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6021 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6022 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6023 sort_pst_symbols (objfile
, pst
);
6025 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
6028 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6029 struct dwarf2_per_cu_data
*iter
;
6031 /* Fill in 'dependencies' here; we fill in 'users' in a
6033 pst
->number_of_dependencies
= len
;
6034 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6035 len
* sizeof (struct symtab
*));
6037 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
6040 pst
->dependencies
[i
] = iter
->v
.psymtab
;
6042 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
6045 /* Get the list of files included in the current compilation unit,
6046 and build a psymtab for each of them. */
6047 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
6049 if (dwarf_read_debug
)
6051 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6053 fprintf_unfiltered (gdb_stdlog
,
6054 "Psymtab for %s unit @0x%x: %s - %s"
6055 ", %d global, %d static syms\n",
6056 per_cu
->is_debug_types
? "type" : "comp",
6057 per_cu
->offset
.sect_off
,
6058 paddress (gdbarch
, pst
->textlow
),
6059 paddress (gdbarch
, pst
->texthigh
),
6060 pst
->n_global_syms
, pst
->n_static_syms
);
6064 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6065 Process compilation unit THIS_CU for a psymtab. */
6068 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
6069 int want_partial_unit
,
6070 enum language pretend_language
)
6072 struct process_psymtab_comp_unit_data info
;
6074 /* If this compilation unit was already read in, free the
6075 cached copy in order to read it in again. This is
6076 necessary because we skipped some symbols when we first
6077 read in the compilation unit (see load_partial_dies).
6078 This problem could be avoided, but the benefit is unclear. */
6079 if (this_cu
->cu
!= NULL
)
6080 free_one_cached_comp_unit (this_cu
);
6082 gdb_assert (! this_cu
->is_debug_types
);
6083 info
.want_partial_unit
= want_partial_unit
;
6084 info
.pretend_language
= pretend_language
;
6085 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
6086 process_psymtab_comp_unit_reader
,
6089 /* Age out any secondary CUs. */
6090 age_cached_comp_units ();
6093 /* Reader function for build_type_psymtabs. */
6096 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
6097 const gdb_byte
*info_ptr
,
6098 struct die_info
*type_unit_die
,
6102 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6103 struct dwarf2_cu
*cu
= reader
->cu
;
6104 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6105 struct signatured_type
*sig_type
;
6106 struct type_unit_group
*tu_group
;
6107 struct attribute
*attr
;
6108 struct partial_die_info
*first_die
;
6109 CORE_ADDR lowpc
, highpc
;
6110 struct partial_symtab
*pst
;
6112 gdb_assert (data
== NULL
);
6113 gdb_assert (per_cu
->is_debug_types
);
6114 sig_type
= (struct signatured_type
*) per_cu
;
6119 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
6120 tu_group
= get_type_unit_group (cu
, attr
);
6122 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
6124 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
6125 cu
->list_in_scope
= &file_symbols
;
6126 pst
= create_partial_symtab (per_cu
, "");
6129 first_die
= load_partial_dies (reader
, info_ptr
, 1);
6131 lowpc
= (CORE_ADDR
) -1;
6132 highpc
= (CORE_ADDR
) 0;
6133 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
6135 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
6136 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
6137 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
6138 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
6139 sort_pst_symbols (objfile
, pst
);
6142 /* Struct used to sort TUs by their abbreviation table offset. */
6144 struct tu_abbrev_offset
6146 struct signatured_type
*sig_type
;
6147 sect_offset abbrev_offset
;
6150 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
6153 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
6155 const struct tu_abbrev_offset
* const *a
= ap
;
6156 const struct tu_abbrev_offset
* const *b
= bp
;
6157 unsigned int aoff
= (*a
)->abbrev_offset
.sect_off
;
6158 unsigned int boff
= (*b
)->abbrev_offset
.sect_off
;
6160 return (aoff
> boff
) - (aoff
< boff
);
6163 /* Efficiently read all the type units.
6164 This does the bulk of the work for build_type_psymtabs.
6166 The efficiency is because we sort TUs by the abbrev table they use and
6167 only read each abbrev table once. In one program there are 200K TUs
6168 sharing 8K abbrev tables.
6170 The main purpose of this function is to support building the
6171 dwarf2_per_objfile->type_unit_groups table.
6172 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
6173 can collapse the search space by grouping them by stmt_list.
6174 The savings can be significant, in the same program from above the 200K TUs
6175 share 8K stmt_list tables.
6177 FUNC is expected to call get_type_unit_group, which will create the
6178 struct type_unit_group if necessary and add it to
6179 dwarf2_per_objfile->type_unit_groups. */
6182 build_type_psymtabs_1 (void)
6184 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6185 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6186 struct cleanup
*cleanups
;
6187 struct abbrev_table
*abbrev_table
;
6188 sect_offset abbrev_offset
;
6189 struct tu_abbrev_offset
*sorted_by_abbrev
;
6190 struct type_unit_group
**iter
;
6193 /* It's up to the caller to not call us multiple times. */
6194 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
6196 if (dwarf2_per_objfile
->n_type_units
== 0)
6199 /* TUs typically share abbrev tables, and there can be way more TUs than
6200 abbrev tables. Sort by abbrev table to reduce the number of times we
6201 read each abbrev table in.
6202 Alternatives are to punt or to maintain a cache of abbrev tables.
6203 This is simpler and efficient enough for now.
6205 Later we group TUs by their DW_AT_stmt_list value (as this defines the
6206 symtab to use). Typically TUs with the same abbrev offset have the same
6207 stmt_list value too so in practice this should work well.
6209 The basic algorithm here is:
6211 sort TUs by abbrev table
6212 for each TU with same abbrev table:
6213 read abbrev table if first user
6214 read TU top level DIE
6215 [IWBN if DWO skeletons had DW_AT_stmt_list]
6218 if (dwarf_read_debug
)
6219 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
6221 /* Sort in a separate table to maintain the order of all_type_units
6222 for .gdb_index: TU indices directly index all_type_units. */
6223 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
6224 dwarf2_per_objfile
->n_type_units
);
6225 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6227 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
6229 sorted_by_abbrev
[i
].sig_type
= sig_type
;
6230 sorted_by_abbrev
[i
].abbrev_offset
=
6231 read_abbrev_offset (sig_type
->per_cu
.section
,
6232 sig_type
->per_cu
.offset
);
6234 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
6235 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
6236 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
6238 abbrev_offset
.sect_off
= ~(unsigned) 0;
6239 abbrev_table
= NULL
;
6240 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
6242 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
6244 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
6246 /* Switch to the next abbrev table if necessary. */
6247 if (abbrev_table
== NULL
6248 || tu
->abbrev_offset
.sect_off
!= abbrev_offset
.sect_off
)
6250 if (abbrev_table
!= NULL
)
6252 abbrev_table_free (abbrev_table
);
6253 /* Reset to NULL in case abbrev_table_read_table throws
6254 an error: abbrev_table_free_cleanup will get called. */
6255 abbrev_table
= NULL
;
6257 abbrev_offset
= tu
->abbrev_offset
;
6259 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
6261 ++tu_stats
->nr_uniq_abbrev_tables
;
6264 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
6265 build_type_psymtabs_reader
, NULL
);
6268 do_cleanups (cleanups
);
6271 /* Print collected type unit statistics. */
6274 print_tu_stats (void)
6276 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
6278 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
6279 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
6280 dwarf2_per_objfile
->n_type_units
);
6281 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
6282 tu_stats
->nr_uniq_abbrev_tables
);
6283 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
6284 tu_stats
->nr_symtabs
);
6285 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
6286 tu_stats
->nr_symtab_sharers
);
6287 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
6288 tu_stats
->nr_stmt_less_type_units
);
6289 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
6290 tu_stats
->nr_all_type_units_reallocs
);
6293 /* Traversal function for build_type_psymtabs. */
6296 build_type_psymtab_dependencies (void **slot
, void *info
)
6298 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6299 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
6300 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
6301 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6302 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
6303 struct signatured_type
*iter
;
6306 gdb_assert (len
> 0);
6307 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
6309 pst
->number_of_dependencies
= len
;
6310 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
6311 len
* sizeof (struct psymtab
*));
6313 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
6316 gdb_assert (iter
->per_cu
.is_debug_types
);
6317 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
6318 iter
->type_unit_group
= tu_group
;
6321 VEC_free (sig_type_ptr
, tu_group
->tus
);
6326 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6327 Build partial symbol tables for the .debug_types comp-units. */
6330 build_type_psymtabs (struct objfile
*objfile
)
6332 if (! create_all_type_units (objfile
))
6335 build_type_psymtabs_1 ();
6338 /* Traversal function for process_skeletonless_type_unit.
6339 Read a TU in a DWO file and build partial symbols for it. */
6342 process_skeletonless_type_unit (void **slot
, void *info
)
6344 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
6345 struct objfile
*objfile
= info
;
6346 struct signatured_type find_entry
, *entry
;
6348 /* If this TU doesn't exist in the global table, add it and read it in. */
6350 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6352 dwarf2_per_objfile
->signatured_types
6353 = allocate_signatured_type_table (objfile
);
6356 find_entry
.signature
= dwo_unit
->signature
;
6357 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
6359 /* If we've already seen this type there's nothing to do. What's happening
6360 is we're doing our own version of comdat-folding here. */
6364 /* This does the job that create_all_type_units would have done for
6366 entry
= add_type_unit (dwo_unit
->signature
, slot
);
6367 fill_in_sig_entry_from_dwo_entry (objfile
, entry
, dwo_unit
);
6370 /* This does the job that build_type_psymtabs_1 would have done. */
6371 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0,
6372 build_type_psymtabs_reader
, NULL
);
6377 /* Traversal function for process_skeletonless_type_units. */
6380 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
6382 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
6384 if (dwo_file
->tus
!= NULL
)
6386 htab_traverse_noresize (dwo_file
->tus
,
6387 process_skeletonless_type_unit
, info
);
6393 /* Scan all TUs of DWO files, verifying we've processed them.
6394 This is needed in case a TU was emitted without its skeleton.
6395 Note: This can't be done until we know what all the DWO files are. */
6398 process_skeletonless_type_units (struct objfile
*objfile
)
6400 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
6401 if (get_dwp_file () == NULL
6402 && dwarf2_per_objfile
->dwo_files
!= NULL
)
6404 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
,
6405 process_dwo_file_for_skeletonless_type_units
,
6410 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6413 psymtabs_addrmap_cleanup (void *o
)
6415 struct objfile
*objfile
= o
;
6417 objfile
->psymtabs_addrmap
= NULL
;
6420 /* Compute the 'user' field for each psymtab in OBJFILE. */
6423 set_partial_user (struct objfile
*objfile
)
6427 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6429 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6430 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
6436 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
6438 /* Set the 'user' field only if it is not already set. */
6439 if (pst
->dependencies
[j
]->user
== NULL
)
6440 pst
->dependencies
[j
]->user
= pst
;
6445 /* Build the partial symbol table by doing a quick pass through the
6446 .debug_info and .debug_abbrev sections. */
6449 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
6451 struct cleanup
*back_to
, *addrmap_cleanup
;
6452 struct obstack temp_obstack
;
6455 if (dwarf_read_debug
)
6457 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
6458 objfile_name (objfile
));
6461 dwarf2_per_objfile
->reading_partial_symbols
= 1;
6463 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
6465 /* Any cached compilation units will be linked by the per-objfile
6466 read_in_chain. Make sure to free them when we're done. */
6467 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
6469 build_type_psymtabs (objfile
);
6471 create_all_comp_units (objfile
);
6473 /* Create a temporary address map on a temporary obstack. We later
6474 copy this to the final obstack. */
6475 obstack_init (&temp_obstack
);
6476 make_cleanup_obstack_free (&temp_obstack
);
6477 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
6478 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
6480 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
6482 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cutu (i
);
6484 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
6487 /* This has to wait until we read the CUs, we need the list of DWOs. */
6488 process_skeletonless_type_units (objfile
);
6490 /* Now that all TUs have been processed we can fill in the dependencies. */
6491 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
6493 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
6494 build_type_psymtab_dependencies
, NULL
);
6497 if (dwarf_read_debug
)
6500 set_partial_user (objfile
);
6502 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
6503 &objfile
->objfile_obstack
);
6504 discard_cleanups (addrmap_cleanup
);
6506 do_cleanups (back_to
);
6508 if (dwarf_read_debug
)
6509 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
6510 objfile_name (objfile
));
6513 /* die_reader_func for load_partial_comp_unit. */
6516 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
6517 const gdb_byte
*info_ptr
,
6518 struct die_info
*comp_unit_die
,
6522 struct dwarf2_cu
*cu
= reader
->cu
;
6524 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
6526 /* Check if comp unit has_children.
6527 If so, read the rest of the partial symbols from this comp unit.
6528 If not, there's no more debug_info for this comp unit. */
6530 load_partial_dies (reader
, info_ptr
, 0);
6533 /* Load the partial DIEs for a secondary CU into memory.
6534 This is also used when rereading a primary CU with load_all_dies. */
6537 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
6539 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
6540 load_partial_comp_unit_reader
, NULL
);
6544 read_comp_units_from_section (struct objfile
*objfile
,
6545 struct dwarf2_section_info
*section
,
6546 unsigned int is_dwz
,
6549 struct dwarf2_per_cu_data
***all_comp_units
)
6551 const gdb_byte
*info_ptr
;
6552 bfd
*abfd
= get_section_bfd_owner (section
);
6554 if (dwarf_read_debug
)
6555 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
6556 get_section_name (section
),
6557 get_section_file_name (section
));
6559 dwarf2_read_section (objfile
, section
);
6561 info_ptr
= section
->buffer
;
6563 while (info_ptr
< section
->buffer
+ section
->size
)
6565 unsigned int length
, initial_length_size
;
6566 struct dwarf2_per_cu_data
*this_cu
;
6569 offset
.sect_off
= info_ptr
- section
->buffer
;
6571 /* Read just enough information to find out where the next
6572 compilation unit is. */
6573 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6575 /* Save the compilation unit for later lookup. */
6576 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
6577 sizeof (struct dwarf2_per_cu_data
));
6578 memset (this_cu
, 0, sizeof (*this_cu
));
6579 this_cu
->offset
= offset
;
6580 this_cu
->length
= length
+ initial_length_size
;
6581 this_cu
->is_dwz
= is_dwz
;
6582 this_cu
->objfile
= objfile
;
6583 this_cu
->section
= section
;
6585 if (*n_comp_units
== *n_allocated
)
6588 *all_comp_units
= xrealloc (*all_comp_units
,
6590 * sizeof (struct dwarf2_per_cu_data
*));
6592 (*all_comp_units
)[*n_comp_units
] = this_cu
;
6595 info_ptr
= info_ptr
+ this_cu
->length
;
6599 /* Create a list of all compilation units in OBJFILE.
6600 This is only done for -readnow and building partial symtabs. */
6603 create_all_comp_units (struct objfile
*objfile
)
6607 struct dwarf2_per_cu_data
**all_comp_units
;
6608 struct dwz_file
*dwz
;
6612 all_comp_units
= xmalloc (n_allocated
6613 * sizeof (struct dwarf2_per_cu_data
*));
6615 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
, 0,
6616 &n_allocated
, &n_comp_units
, &all_comp_units
);
6618 dwz
= dwarf2_get_dwz_file ();
6620 read_comp_units_from_section (objfile
, &dwz
->info
, 1,
6621 &n_allocated
, &n_comp_units
,
6624 dwarf2_per_objfile
->all_comp_units
6625 = obstack_alloc (&objfile
->objfile_obstack
,
6626 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6627 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
6628 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
6629 xfree (all_comp_units
);
6630 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
6633 /* Process all loaded DIEs for compilation unit CU, starting at
6634 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
6635 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6636 DW_AT_ranges). See the comments of add_partial_subprogram on how
6637 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
6640 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
6641 CORE_ADDR
*highpc
, int set_addrmap
,
6642 struct dwarf2_cu
*cu
)
6644 struct partial_die_info
*pdi
;
6646 /* Now, march along the PDI's, descending into ones which have
6647 interesting children but skipping the children of the other ones,
6648 until we reach the end of the compilation unit. */
6654 fixup_partial_die (pdi
, cu
);
6656 /* Anonymous namespaces or modules have no name but have interesting
6657 children, so we need to look at them. Ditto for anonymous
6660 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
6661 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
6662 || pdi
->tag
== DW_TAG_imported_unit
)
6666 case DW_TAG_subprogram
:
6667 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6669 case DW_TAG_constant
:
6670 case DW_TAG_variable
:
6671 case DW_TAG_typedef
:
6672 case DW_TAG_union_type
:
6673 if (!pdi
->is_declaration
)
6675 add_partial_symbol (pdi
, cu
);
6678 case DW_TAG_class_type
:
6679 case DW_TAG_interface_type
:
6680 case DW_TAG_structure_type
:
6681 if (!pdi
->is_declaration
)
6683 add_partial_symbol (pdi
, cu
);
6686 case DW_TAG_enumeration_type
:
6687 if (!pdi
->is_declaration
)
6688 add_partial_enumeration (pdi
, cu
);
6690 case DW_TAG_base_type
:
6691 case DW_TAG_subrange_type
:
6692 /* File scope base type definitions are added to the partial
6694 add_partial_symbol (pdi
, cu
);
6696 case DW_TAG_namespace
:
6697 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6700 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
6702 case DW_TAG_imported_unit
:
6704 struct dwarf2_per_cu_data
*per_cu
;
6706 /* For now we don't handle imported units in type units. */
6707 if (cu
->per_cu
->is_debug_types
)
6709 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6710 " supported in type units [in module %s]"),
6711 objfile_name (cu
->objfile
));
6714 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
6718 /* Go read the partial unit, if needed. */
6719 if (per_cu
->v
.psymtab
== NULL
)
6720 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
6722 VEC_safe_push (dwarf2_per_cu_ptr
,
6723 cu
->per_cu
->imported_symtabs
, per_cu
);
6726 case DW_TAG_imported_declaration
:
6727 add_partial_symbol (pdi
, cu
);
6734 /* If the die has a sibling, skip to the sibling. */
6736 pdi
= pdi
->die_sibling
;
6740 /* Functions used to compute the fully scoped name of a partial DIE.
6742 Normally, this is simple. For C++, the parent DIE's fully scoped
6743 name is concatenated with "::" and the partial DIE's name. For
6744 Java, the same thing occurs except that "." is used instead of "::".
6745 Enumerators are an exception; they use the scope of their parent
6746 enumeration type, i.e. the name of the enumeration type is not
6747 prepended to the enumerator.
6749 There are two complexities. One is DW_AT_specification; in this
6750 case "parent" means the parent of the target of the specification,
6751 instead of the direct parent of the DIE. The other is compilers
6752 which do not emit DW_TAG_namespace; in this case we try to guess
6753 the fully qualified name of structure types from their members'
6754 linkage names. This must be done using the DIE's children rather
6755 than the children of any DW_AT_specification target. We only need
6756 to do this for structures at the top level, i.e. if the target of
6757 any DW_AT_specification (if any; otherwise the DIE itself) does not
6760 /* Compute the scope prefix associated with PDI's parent, in
6761 compilation unit CU. The result will be allocated on CU's
6762 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6763 field. NULL is returned if no prefix is necessary. */
6765 partial_die_parent_scope (struct partial_die_info
*pdi
,
6766 struct dwarf2_cu
*cu
)
6768 const char *grandparent_scope
;
6769 struct partial_die_info
*parent
, *real_pdi
;
6771 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6772 then this means the parent of the specification DIE. */
6775 while (real_pdi
->has_specification
)
6776 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
6777 real_pdi
->spec_is_dwz
, cu
);
6779 parent
= real_pdi
->die_parent
;
6783 if (parent
->scope_set
)
6784 return parent
->scope
;
6786 fixup_partial_die (parent
, cu
);
6788 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
6790 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6791 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6792 Work around this problem here. */
6793 if (cu
->language
== language_cplus
6794 && parent
->tag
== DW_TAG_namespace
6795 && strcmp (parent
->name
, "::") == 0
6796 && grandparent_scope
== NULL
)
6798 parent
->scope
= NULL
;
6799 parent
->scope_set
= 1;
6803 if (pdi
->tag
== DW_TAG_enumerator
)
6804 /* Enumerators should not get the name of the enumeration as a prefix. */
6805 parent
->scope
= grandparent_scope
;
6806 else if (parent
->tag
== DW_TAG_namespace
6807 || parent
->tag
== DW_TAG_module
6808 || parent
->tag
== DW_TAG_structure_type
6809 || parent
->tag
== DW_TAG_class_type
6810 || parent
->tag
== DW_TAG_interface_type
6811 || parent
->tag
== DW_TAG_union_type
6812 || parent
->tag
== DW_TAG_enumeration_type
)
6814 if (grandparent_scope
== NULL
)
6815 parent
->scope
= parent
->name
;
6817 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
6819 parent
->name
, 0, cu
);
6823 /* FIXME drow/2004-04-01: What should we be doing with
6824 function-local names? For partial symbols, we should probably be
6826 complaint (&symfile_complaints
,
6827 _("unhandled containing DIE tag %d for DIE at %d"),
6828 parent
->tag
, pdi
->offset
.sect_off
);
6829 parent
->scope
= grandparent_scope
;
6832 parent
->scope_set
= 1;
6833 return parent
->scope
;
6836 /* Return the fully scoped name associated with PDI, from compilation unit
6837 CU. The result will be allocated with malloc. */
6840 partial_die_full_name (struct partial_die_info
*pdi
,
6841 struct dwarf2_cu
*cu
)
6843 const char *parent_scope
;
6845 /* If this is a template instantiation, we can not work out the
6846 template arguments from partial DIEs. So, unfortunately, we have
6847 to go through the full DIEs. At least any work we do building
6848 types here will be reused if full symbols are loaded later. */
6849 if (pdi
->has_template_arguments
)
6851 fixup_partial_die (pdi
, cu
);
6853 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
6855 struct die_info
*die
;
6856 struct attribute attr
;
6857 struct dwarf2_cu
*ref_cu
= cu
;
6859 /* DW_FORM_ref_addr is using section offset. */
6861 attr
.form
= DW_FORM_ref_addr
;
6862 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
6863 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
6865 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
6869 parent_scope
= partial_die_parent_scope (pdi
, cu
);
6870 if (parent_scope
== NULL
)
6873 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
6877 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
6879 struct objfile
*objfile
= cu
->objfile
;
6880 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6882 const char *actual_name
= NULL
;
6884 char *built_actual_name
;
6886 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6888 built_actual_name
= partial_die_full_name (pdi
, cu
);
6889 if (built_actual_name
!= NULL
)
6890 actual_name
= built_actual_name
;
6892 if (actual_name
== NULL
)
6893 actual_name
= pdi
->name
;
6897 case DW_TAG_subprogram
:
6898 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
);
6899 if (pdi
->is_external
|| cu
->language
== language_ada
)
6901 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6902 of the global scope. But in Ada, we want to be able to access
6903 nested procedures globally. So all Ada subprograms are stored
6904 in the global scope. */
6905 /* prim_record_minimal_symbol (actual_name, addr, mst_text,
6907 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6908 built_actual_name
!= NULL
,
6909 VAR_DOMAIN
, LOC_BLOCK
,
6910 &objfile
->global_psymbols
,
6911 0, addr
, cu
->language
, objfile
);
6915 /* prim_record_minimal_symbol (actual_name, addr, mst_file_text,
6917 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6918 built_actual_name
!= NULL
,
6919 VAR_DOMAIN
, LOC_BLOCK
,
6920 &objfile
->static_psymbols
,
6921 0, addr
, cu
->language
, objfile
);
6924 case DW_TAG_constant
:
6926 struct psymbol_allocation_list
*list
;
6928 if (pdi
->is_external
)
6929 list
= &objfile
->global_psymbols
;
6931 list
= &objfile
->static_psymbols
;
6932 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6933 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
6934 list
, 0, 0, cu
->language
, objfile
);
6937 case DW_TAG_variable
:
6939 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
6943 && !dwarf2_per_objfile
->has_section_at_zero
)
6945 /* A global or static variable may also have been stripped
6946 out by the linker if unused, in which case its address
6947 will be nullified; do not add such variables into partial
6948 symbol table then. */
6950 else if (pdi
->is_external
)
6953 Don't enter into the minimal symbol tables as there is
6954 a minimal symbol table entry from the ELF symbols already.
6955 Enter into partial symbol table if it has a location
6956 descriptor or a type.
6957 If the location descriptor is missing, new_symbol will create
6958 a LOC_UNRESOLVED symbol, the address of the variable will then
6959 be determined from the minimal symbol table whenever the variable
6961 The address for the partial symbol table entry is not
6962 used by GDB, but it comes in handy for debugging partial symbol
6965 if (pdi
->d
.locdesc
|| pdi
->has_type
)
6966 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6967 built_actual_name
!= NULL
,
6968 VAR_DOMAIN
, LOC_STATIC
,
6969 &objfile
->global_psymbols
,
6971 cu
->language
, objfile
);
6975 int has_loc
= pdi
->d
.locdesc
!= NULL
;
6977 /* Static Variable. Skip symbols whose value we cannot know (those
6978 without location descriptors or constant values). */
6979 if (!has_loc
&& !pdi
->has_const_value
)
6981 xfree (built_actual_name
);
6985 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6986 mst_file_data, objfile); */
6987 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6988 built_actual_name
!= NULL
,
6989 VAR_DOMAIN
, LOC_STATIC
,
6990 &objfile
->static_psymbols
,
6992 has_loc
? addr
+ baseaddr
: (CORE_ADDR
) 0,
6993 cu
->language
, objfile
);
6996 case DW_TAG_typedef
:
6997 case DW_TAG_base_type
:
6998 case DW_TAG_subrange_type
:
6999 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7000 built_actual_name
!= NULL
,
7001 VAR_DOMAIN
, LOC_TYPEDEF
,
7002 &objfile
->static_psymbols
,
7003 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7005 case DW_TAG_imported_declaration
:
7006 case DW_TAG_namespace
:
7007 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7008 built_actual_name
!= NULL
,
7009 VAR_DOMAIN
, LOC_TYPEDEF
,
7010 &objfile
->global_psymbols
,
7011 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7014 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7015 built_actual_name
!= NULL
,
7016 MODULE_DOMAIN
, LOC_TYPEDEF
,
7017 &objfile
->global_psymbols
,
7018 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7020 case DW_TAG_class_type
:
7021 case DW_TAG_interface_type
:
7022 case DW_TAG_structure_type
:
7023 case DW_TAG_union_type
:
7024 case DW_TAG_enumeration_type
:
7025 /* Skip external references. The DWARF standard says in the section
7026 about "Structure, Union, and Class Type Entries": "An incomplete
7027 structure, union or class type is represented by a structure,
7028 union or class entry that does not have a byte size attribute
7029 and that has a DW_AT_declaration attribute." */
7030 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
7032 xfree (built_actual_name
);
7036 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
7037 static vs. global. */
7038 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7039 built_actual_name
!= NULL
,
7040 STRUCT_DOMAIN
, LOC_TYPEDEF
,
7041 (cu
->language
== language_cplus
7042 || cu
->language
== language_java
)
7043 ? &objfile
->global_psymbols
7044 : &objfile
->static_psymbols
,
7045 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7048 case DW_TAG_enumerator
:
7049 add_psymbol_to_list (actual_name
, strlen (actual_name
),
7050 built_actual_name
!= NULL
,
7051 VAR_DOMAIN
, LOC_CONST
,
7052 (cu
->language
== language_cplus
7053 || cu
->language
== language_java
)
7054 ? &objfile
->global_psymbols
7055 : &objfile
->static_psymbols
,
7056 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
7062 xfree (built_actual_name
);
7065 /* Read a partial die corresponding to a namespace; also, add a symbol
7066 corresponding to that namespace to the symbol table. NAMESPACE is
7067 the name of the enclosing namespace. */
7070 add_partial_namespace (struct partial_die_info
*pdi
,
7071 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7072 int set_addrmap
, struct dwarf2_cu
*cu
)
7074 /* Add a symbol for the namespace. */
7076 add_partial_symbol (pdi
, cu
);
7078 /* Now scan partial symbols in that namespace. */
7080 if (pdi
->has_children
)
7081 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7084 /* Read a partial die corresponding to a Fortran module. */
7087 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
7088 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
7090 /* Add a symbol for the namespace. */
7092 add_partial_symbol (pdi
, cu
);
7094 /* Now scan partial symbols in that module. */
7096 if (pdi
->has_children
)
7097 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
7100 /* Read a partial die corresponding to a subprogram and create a partial
7101 symbol for that subprogram. When the CU language allows it, this
7102 routine also defines a partial symbol for each nested subprogram
7103 that this subprogram contains. If SET_ADDRMAP is true, record the
7104 covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
7105 and highest PC values found in PDI.
7107 PDI may also be a lexical block, in which case we simply search
7108 recursively for subprograms defined inside that lexical block.
7109 Again, this is only performed when the CU language allows this
7110 type of definitions. */
7113 add_partial_subprogram (struct partial_die_info
*pdi
,
7114 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
7115 int set_addrmap
, struct dwarf2_cu
*cu
)
7117 if (pdi
->tag
== DW_TAG_subprogram
)
7119 if (pdi
->has_pc_info
)
7121 if (pdi
->lowpc
< *lowpc
)
7122 *lowpc
= pdi
->lowpc
;
7123 if (pdi
->highpc
> *highpc
)
7124 *highpc
= pdi
->highpc
;
7127 struct objfile
*objfile
= cu
->objfile
;
7128 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7133 baseaddr
= ANOFFSET (objfile
->section_offsets
,
7134 SECT_OFF_TEXT (objfile
));
7135 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7136 pdi
->lowpc
+ baseaddr
);
7137 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
7138 pdi
->highpc
+ baseaddr
);
7139 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
7140 cu
->per_cu
->v
.psymtab
);
7144 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
7146 if (!pdi
->is_declaration
)
7147 /* Ignore subprogram DIEs that do not have a name, they are
7148 illegal. Do not emit a complaint at this point, we will
7149 do so when we convert this psymtab into a symtab. */
7151 add_partial_symbol (pdi
, cu
);
7155 if (! pdi
->has_children
)
7158 if (cu
->language
== language_ada
)
7160 pdi
= pdi
->die_child
;
7163 fixup_partial_die (pdi
, cu
);
7164 if (pdi
->tag
== DW_TAG_subprogram
7165 || pdi
->tag
== DW_TAG_lexical_block
)
7166 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7167 pdi
= pdi
->die_sibling
;
7172 /* Read a partial die corresponding to an enumeration type. */
7175 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
7176 struct dwarf2_cu
*cu
)
7178 struct partial_die_info
*pdi
;
7180 if (enum_pdi
->name
!= NULL
)
7181 add_partial_symbol (enum_pdi
, cu
);
7183 pdi
= enum_pdi
->die_child
;
7186 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
7187 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
7189 add_partial_symbol (pdi
, cu
);
7190 pdi
= pdi
->die_sibling
;
7194 /* Return the initial uleb128 in the die at INFO_PTR. */
7197 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
7199 unsigned int bytes_read
;
7201 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7204 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7205 Return the corresponding abbrev, or NULL if the number is zero (indicating
7206 an empty DIE). In either case *BYTES_READ will be set to the length of
7207 the initial number. */
7209 static struct abbrev_info
*
7210 peek_die_abbrev (const gdb_byte
*info_ptr
, unsigned int *bytes_read
,
7211 struct dwarf2_cu
*cu
)
7213 bfd
*abfd
= cu
->objfile
->obfd
;
7214 unsigned int abbrev_number
;
7215 struct abbrev_info
*abbrev
;
7217 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
7219 if (abbrev_number
== 0)
7222 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
7225 error (_("Dwarf Error: Could not find abbrev number %d in %s"
7226 " at offset 0x%x [in module %s]"),
7227 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
7228 cu
->header
.offset
.sect_off
, bfd_get_filename (abfd
));
7234 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7235 Returns a pointer to the end of a series of DIEs, terminated by an empty
7236 DIE. Any children of the skipped DIEs will also be skipped. */
7238 static const gdb_byte
*
7239 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
7241 struct dwarf2_cu
*cu
= reader
->cu
;
7242 struct abbrev_info
*abbrev
;
7243 unsigned int bytes_read
;
7247 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
7249 return info_ptr
+ bytes_read
;
7251 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
7255 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7256 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7257 abbrev corresponding to that skipped uleb128 should be passed in
7258 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7261 static const gdb_byte
*
7262 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
7263 struct abbrev_info
*abbrev
)
7265 unsigned int bytes_read
;
7266 struct attribute attr
;
7267 bfd
*abfd
= reader
->abfd
;
7268 struct dwarf2_cu
*cu
= reader
->cu
;
7269 const gdb_byte
*buffer
= reader
->buffer
;
7270 const gdb_byte
*buffer_end
= reader
->buffer_end
;
7271 const gdb_byte
*start_info_ptr
= info_ptr
;
7272 unsigned int form
, i
;
7274 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
7276 /* The only abbrev we care about is DW_AT_sibling. */
7277 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
7279 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
7280 if (attr
.form
== DW_FORM_ref_addr
)
7281 complaint (&symfile_complaints
,
7282 _("ignoring absolute DW_AT_sibling"));
7285 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
7286 const gdb_byte
*sibling_ptr
= buffer
+ off
;
7288 if (sibling_ptr
< info_ptr
)
7289 complaint (&symfile_complaints
,
7290 _("DW_AT_sibling points backwards"));
7291 else if (sibling_ptr
> reader
->buffer_end
)
7292 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
7298 /* If it isn't DW_AT_sibling, skip this attribute. */
7299 form
= abbrev
->attrs
[i
].form
;
7303 case DW_FORM_ref_addr
:
7304 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7305 and later it is offset sized. */
7306 if (cu
->header
.version
== 2)
7307 info_ptr
+= cu
->header
.addr_size
;
7309 info_ptr
+= cu
->header
.offset_size
;
7311 case DW_FORM_GNU_ref_alt
:
7312 info_ptr
+= cu
->header
.offset_size
;
7315 info_ptr
+= cu
->header
.addr_size
;
7322 case DW_FORM_flag_present
:
7334 case DW_FORM_ref_sig8
:
7337 case DW_FORM_string
:
7338 read_direct_string (abfd
, info_ptr
, &bytes_read
);
7339 info_ptr
+= bytes_read
;
7341 case DW_FORM_sec_offset
:
7343 case DW_FORM_GNU_strp_alt
:
7344 info_ptr
+= cu
->header
.offset_size
;
7346 case DW_FORM_exprloc
:
7348 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7349 info_ptr
+= bytes_read
;
7351 case DW_FORM_block1
:
7352 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
7354 case DW_FORM_block2
:
7355 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
7357 case DW_FORM_block4
:
7358 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
7362 case DW_FORM_ref_udata
:
7363 case DW_FORM_GNU_addr_index
:
7364 case DW_FORM_GNU_str_index
:
7365 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
7367 case DW_FORM_indirect
:
7368 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
7369 info_ptr
+= bytes_read
;
7370 /* We need to continue parsing from here, so just go back to
7372 goto skip_attribute
;
7375 error (_("Dwarf Error: Cannot handle %s "
7376 "in DWARF reader [in module %s]"),
7377 dwarf_form_name (form
),
7378 bfd_get_filename (abfd
));
7382 if (abbrev
->has_children
)
7383 return skip_children (reader
, info_ptr
);
7388 /* Locate ORIG_PDI's sibling.
7389 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7391 static const gdb_byte
*
7392 locate_pdi_sibling (const struct die_reader_specs
*reader
,
7393 struct partial_die_info
*orig_pdi
,
7394 const gdb_byte
*info_ptr
)
7396 /* Do we know the sibling already? */
7398 if (orig_pdi
->sibling
)
7399 return orig_pdi
->sibling
;
7401 /* Are there any children to deal with? */
7403 if (!orig_pdi
->has_children
)
7406 /* Skip the children the long way. */
7408 return skip_children (reader
, info_ptr
);
7411 /* Expand this partial symbol table into a full symbol table. SELF is
7415 dwarf2_read_symtab (struct partial_symtab
*self
,
7416 struct objfile
*objfile
)
7420 warning (_("bug: psymtab for %s is already read in."),
7427 printf_filtered (_("Reading in symbols for %s..."),
7429 gdb_flush (gdb_stdout
);
7432 /* Restore our global data. */
7433 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
7435 /* If this psymtab is constructed from a debug-only objfile, the
7436 has_section_at_zero flag will not necessarily be correct. We
7437 can get the correct value for this flag by looking at the data
7438 associated with the (presumably stripped) associated objfile. */
7439 if (objfile
->separate_debug_objfile_backlink
)
7441 struct dwarf2_per_objfile
*dpo_backlink
7442 = objfile_data (objfile
->separate_debug_objfile_backlink
,
7443 dwarf2_objfile_data_key
);
7445 dwarf2_per_objfile
->has_section_at_zero
7446 = dpo_backlink
->has_section_at_zero
;
7449 dwarf2_per_objfile
->reading_partial_symbols
= 0;
7451 psymtab_to_symtab_1 (self
);
7453 /* Finish up the debug error message. */
7455 printf_filtered (_("done.\n"));
7458 process_cu_includes ();
7461 /* Reading in full CUs. */
7463 /* Add PER_CU to the queue. */
7466 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
7467 enum language pretend_language
)
7469 struct dwarf2_queue_item
*item
;
7472 item
= xmalloc (sizeof (*item
));
7473 item
->per_cu
= per_cu
;
7474 item
->pretend_language
= pretend_language
;
7477 if (dwarf2_queue
== NULL
)
7478 dwarf2_queue
= item
;
7480 dwarf2_queue_tail
->next
= item
;
7482 dwarf2_queue_tail
= item
;
7485 /* If PER_CU is not yet queued, add it to the queue.
7486 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7488 The result is non-zero if PER_CU was queued, otherwise the result is zero
7489 meaning either PER_CU is already queued or it is already loaded.
7491 N.B. There is an invariant here that if a CU is queued then it is loaded.
7492 The caller is required to load PER_CU if we return non-zero. */
7495 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
7496 struct dwarf2_per_cu_data
*per_cu
,
7497 enum language pretend_language
)
7499 /* We may arrive here during partial symbol reading, if we need full
7500 DIEs to process an unusual case (e.g. template arguments). Do
7501 not queue PER_CU, just tell our caller to load its DIEs. */
7502 if (dwarf2_per_objfile
->reading_partial_symbols
)
7504 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
7509 /* Mark the dependence relation so that we don't flush PER_CU
7511 if (dependent_cu
!= NULL
)
7512 dwarf2_add_dependence (dependent_cu
, per_cu
);
7514 /* If it's already on the queue, we have nothing to do. */
7518 /* If the compilation unit is already loaded, just mark it as
7520 if (per_cu
->cu
!= NULL
)
7522 per_cu
->cu
->last_used
= 0;
7526 /* Add it to the queue. */
7527 queue_comp_unit (per_cu
, pretend_language
);
7532 /* Process the queue. */
7535 process_queue (void)
7537 struct dwarf2_queue_item
*item
, *next_item
;
7539 if (dwarf_read_debug
)
7541 fprintf_unfiltered (gdb_stdlog
,
7542 "Expanding one or more symtabs of objfile %s ...\n",
7543 objfile_name (dwarf2_per_objfile
->objfile
));
7546 /* The queue starts out with one item, but following a DIE reference
7547 may load a new CU, adding it to the end of the queue. */
7548 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
7550 if ((dwarf2_per_objfile
->using_index
7551 ? !item
->per_cu
->v
.quick
->compunit_symtab
7552 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
7553 /* Skip dummy CUs. */
7554 && item
->per_cu
->cu
!= NULL
)
7556 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
7557 unsigned int debug_print_threshold
;
7560 if (per_cu
->is_debug_types
)
7562 struct signatured_type
*sig_type
=
7563 (struct signatured_type
*) per_cu
;
7565 sprintf (buf
, "TU %s at offset 0x%x",
7566 hex_string (sig_type
->signature
),
7567 per_cu
->offset
.sect_off
);
7568 /* There can be 100s of TUs.
7569 Only print them in verbose mode. */
7570 debug_print_threshold
= 2;
7574 sprintf (buf
, "CU at offset 0x%x", per_cu
->offset
.sect_off
);
7575 debug_print_threshold
= 1;
7578 if (dwarf_read_debug
>= debug_print_threshold
)
7579 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
7581 if (per_cu
->is_debug_types
)
7582 process_full_type_unit (per_cu
, item
->pretend_language
);
7584 process_full_comp_unit (per_cu
, item
->pretend_language
);
7586 if (dwarf_read_debug
>= debug_print_threshold
)
7587 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
7590 item
->per_cu
->queued
= 0;
7591 next_item
= item
->next
;
7595 dwarf2_queue_tail
= NULL
;
7597 if (dwarf_read_debug
)
7599 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
7600 objfile_name (dwarf2_per_objfile
->objfile
));
7604 /* Free all allocated queue entries. This function only releases anything if
7605 an error was thrown; if the queue was processed then it would have been
7606 freed as we went along. */
7609 dwarf2_release_queue (void *dummy
)
7611 struct dwarf2_queue_item
*item
, *last
;
7613 item
= dwarf2_queue
;
7616 /* Anything still marked queued is likely to be in an
7617 inconsistent state, so discard it. */
7618 if (item
->per_cu
->queued
)
7620 if (item
->per_cu
->cu
!= NULL
)
7621 free_one_cached_comp_unit (item
->per_cu
);
7622 item
->per_cu
->queued
= 0;
7630 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
7633 /* Read in full symbols for PST, and anything it depends on. */
7636 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
7638 struct dwarf2_per_cu_data
*per_cu
;
7644 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
7645 if (!pst
->dependencies
[i
]->readin
7646 && pst
->dependencies
[i
]->user
== NULL
)
7648 /* Inform about additional files that need to be read in. */
7651 /* FIXME: i18n: Need to make this a single string. */
7652 fputs_filtered (" ", gdb_stdout
);
7654 fputs_filtered ("and ", gdb_stdout
);
7656 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
7657 wrap_here (""); /* Flush output. */
7658 gdb_flush (gdb_stdout
);
7660 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
7663 per_cu
= pst
->read_symtab_private
;
7667 /* It's an include file, no symbols to read for it.
7668 Everything is in the parent symtab. */
7673 dw2_do_instantiate_symtab (per_cu
);
7676 /* Trivial hash function for die_info: the hash value of a DIE
7677 is its offset in .debug_info for this objfile. */
7680 die_hash (const void *item
)
7682 const struct die_info
*die
= item
;
7684 return die
->offset
.sect_off
;
7687 /* Trivial comparison function for die_info structures: two DIEs
7688 are equal if they have the same offset. */
7691 die_eq (const void *item_lhs
, const void *item_rhs
)
7693 const struct die_info
*die_lhs
= item_lhs
;
7694 const struct die_info
*die_rhs
= item_rhs
;
7696 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
7699 /* die_reader_func for load_full_comp_unit.
7700 This is identical to read_signatured_type_reader,
7701 but is kept separate for now. */
7704 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
7705 const gdb_byte
*info_ptr
,
7706 struct die_info
*comp_unit_die
,
7710 struct dwarf2_cu
*cu
= reader
->cu
;
7711 enum language
*language_ptr
= data
;
7713 gdb_assert (cu
->die_hash
== NULL
);
7715 htab_create_alloc_ex (cu
->header
.length
/ 12,
7719 &cu
->comp_unit_obstack
,
7720 hashtab_obstack_allocate
,
7721 dummy_obstack_deallocate
);
7724 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
7725 &info_ptr
, comp_unit_die
);
7726 cu
->dies
= comp_unit_die
;
7727 /* comp_unit_die is not stored in die_hash, no need. */
7729 /* We try not to read any attributes in this function, because not
7730 all CUs needed for references have been loaded yet, and symbol
7731 table processing isn't initialized. But we have to set the CU language,
7732 or we won't be able to build types correctly.
7733 Similarly, if we do not read the producer, we can not apply
7734 producer-specific interpretation. */
7735 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
7738 /* Load the DIEs associated with PER_CU into memory. */
7741 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7742 enum language pretend_language
)
7744 gdb_assert (! this_cu
->is_debug_types
);
7746 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
7747 load_full_comp_unit_reader
, &pretend_language
);
7750 /* Add a DIE to the delayed physname list. */
7753 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
7754 const char *name
, struct die_info
*die
,
7755 struct dwarf2_cu
*cu
)
7757 struct delayed_method_info mi
;
7759 mi
.fnfield_index
= fnfield_index
;
7763 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
7766 /* A cleanup for freeing the delayed method list. */
7769 free_delayed_list (void *ptr
)
7771 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
7772 if (cu
->method_list
!= NULL
)
7774 VEC_free (delayed_method_info
, cu
->method_list
);
7775 cu
->method_list
= NULL
;
7779 /* Compute the physnames of any methods on the CU's method list.
7781 The computation of method physnames is delayed in order to avoid the
7782 (bad) condition that one of the method's formal parameters is of an as yet
7786 compute_delayed_physnames (struct dwarf2_cu
*cu
)
7789 struct delayed_method_info
*mi
;
7790 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
7792 const char *physname
;
7793 struct fn_fieldlist
*fn_flp
7794 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
7795 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
7796 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
->index
)
7797 = physname
? physname
: "";
7801 /* Go objects should be embedded in a DW_TAG_module DIE,
7802 and it's not clear if/how imported objects will appear.
7803 To keep Go support simple until that's worked out,
7804 go back through what we've read and create something usable.
7805 We could do this while processing each DIE, and feels kinda cleaner,
7806 but that way is more invasive.
7807 This is to, for example, allow the user to type "p var" or "b main"
7808 without having to specify the package name, and allow lookups
7809 of module.object to work in contexts that use the expression
7813 fixup_go_packaging (struct dwarf2_cu
*cu
)
7815 char *package_name
= NULL
;
7816 struct pending
*list
;
7819 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
7821 for (i
= 0; i
< list
->nsyms
; ++i
)
7823 struct symbol
*sym
= list
->symbol
[i
];
7825 if (SYMBOL_LANGUAGE (sym
) == language_go
7826 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
7828 char *this_package_name
= go_symbol_package_name (sym
);
7830 if (this_package_name
== NULL
)
7832 if (package_name
== NULL
)
7833 package_name
= this_package_name
;
7836 if (strcmp (package_name
, this_package_name
) != 0)
7837 complaint (&symfile_complaints
,
7838 _("Symtab %s has objects from two different Go packages: %s and %s"),
7839 (symbol_symtab (sym
) != NULL
7840 ? symtab_to_filename_for_display
7841 (symbol_symtab (sym
))
7842 : objfile_name (cu
->objfile
)),
7843 this_package_name
, package_name
);
7844 xfree (this_package_name
);
7850 if (package_name
!= NULL
)
7852 struct objfile
*objfile
= cu
->objfile
;
7853 const char *saved_package_name
7854 = obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
7856 strlen (package_name
));
7857 struct type
*type
= init_type (TYPE_CODE_MODULE
, 0, 0,
7858 saved_package_name
, objfile
);
7861 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7863 sym
= allocate_symbol (objfile
);
7864 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
7865 SYMBOL_SET_NAMES (sym
, saved_package_name
,
7866 strlen (saved_package_name
), 0, objfile
);
7867 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7868 e.g., "main" finds the "main" module and not C's main(). */
7869 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7870 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
7871 SYMBOL_TYPE (sym
) = type
;
7873 add_symbol_to_list (sym
, &global_symbols
);
7875 xfree (package_name
);
7879 /* Return the symtab for PER_CU. This works properly regardless of
7880 whether we're using the index or psymtabs. */
7882 static struct compunit_symtab
*
7883 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
7885 return (dwarf2_per_objfile
->using_index
7886 ? per_cu
->v
.quick
->compunit_symtab
7887 : per_cu
->v
.psymtab
->compunit_symtab
);
7890 /* A helper function for computing the list of all symbol tables
7891 included by PER_CU. */
7894 recursively_compute_inclusions (VEC (compunit_symtab_ptr
) **result
,
7895 htab_t all_children
, htab_t all_type_symtabs
,
7896 struct dwarf2_per_cu_data
*per_cu
,
7897 struct compunit_symtab
*immediate_parent
)
7901 struct compunit_symtab
*cust
;
7902 struct dwarf2_per_cu_data
*iter
;
7904 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
7907 /* This inclusion and its children have been processed. */
7912 /* Only add a CU if it has a symbol table. */
7913 cust
= get_compunit_symtab (per_cu
);
7916 /* If this is a type unit only add its symbol table if we haven't
7917 seen it yet (type unit per_cu's can share symtabs). */
7918 if (per_cu
->is_debug_types
)
7920 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
7924 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7925 if (cust
->user
== NULL
)
7926 cust
->user
= immediate_parent
;
7931 VEC_safe_push (compunit_symtab_ptr
, *result
, cust
);
7932 if (cust
->user
== NULL
)
7933 cust
->user
= immediate_parent
;
7938 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
7941 recursively_compute_inclusions (result
, all_children
,
7942 all_type_symtabs
, iter
, cust
);
7946 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
7950 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
7952 gdb_assert (! per_cu
->is_debug_types
);
7954 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
7957 struct dwarf2_per_cu_data
*per_cu_iter
;
7958 struct compunit_symtab
*compunit_symtab_iter
;
7959 VEC (compunit_symtab_ptr
) *result_symtabs
= NULL
;
7960 htab_t all_children
, all_type_symtabs
;
7961 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
7963 /* If we don't have a symtab, we can just skip this case. */
7967 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7968 NULL
, xcalloc
, xfree
);
7969 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7970 NULL
, xcalloc
, xfree
);
7973 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
7977 recursively_compute_inclusions (&result_symtabs
, all_children
,
7978 all_type_symtabs
, per_cu_iter
,
7982 /* Now we have a transitive closure of all the included symtabs. */
7983 len
= VEC_length (compunit_symtab_ptr
, result_symtabs
);
7985 = obstack_alloc (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
7986 (len
+ 1) * sizeof (struct compunit_symtab
*));
7988 VEC_iterate (compunit_symtab_ptr
, result_symtabs
, ix
,
7989 compunit_symtab_iter
);
7991 cust
->includes
[ix
] = compunit_symtab_iter
;
7992 cust
->includes
[len
] = NULL
;
7994 VEC_free (compunit_symtab_ptr
, result_symtabs
);
7995 htab_delete (all_children
);
7996 htab_delete (all_type_symtabs
);
8000 /* Compute the 'includes' field for the symtabs of all the CUs we just
8004 process_cu_includes (void)
8007 struct dwarf2_per_cu_data
*iter
;
8010 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
8014 if (! iter
->is_debug_types
)
8015 compute_compunit_symtab_includes (iter
);
8018 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
8021 /* Generate full symbol information for PER_CU, whose DIEs have
8022 already been loaded into memory. */
8025 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
8026 enum language pretend_language
)
8028 struct dwarf2_cu
*cu
= per_cu
->cu
;
8029 struct objfile
*objfile
= per_cu
->objfile
;
8030 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8031 CORE_ADDR lowpc
, highpc
;
8032 struct compunit_symtab
*cust
;
8033 struct cleanup
*back_to
, *delayed_list_cleanup
;
8035 struct block
*static_block
;
8038 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8041 back_to
= make_cleanup (really_free_pendings
, NULL
);
8042 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8044 cu
->list_in_scope
= &file_symbols
;
8046 cu
->language
= pretend_language
;
8047 cu
->language_defn
= language_def (cu
->language
);
8049 /* Do line number decoding in read_file_scope () */
8050 process_die (cu
->dies
, cu
);
8052 /* For now fudge the Go package. */
8053 if (cu
->language
== language_go
)
8054 fixup_go_packaging (cu
);
8056 /* Now that we have processed all the DIEs in the CU, all the types
8057 should be complete, and it should now be safe to compute all of the
8059 compute_delayed_physnames (cu
);
8060 do_cleanups (delayed_list_cleanup
);
8062 /* Some compilers don't define a DW_AT_high_pc attribute for the
8063 compilation unit. If the DW_AT_high_pc is missing, synthesize
8064 it, by scanning the DIE's below the compilation unit. */
8065 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
8067 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
8068 static_block
= end_symtab_get_static_block (addr
, 0, 1);
8070 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
8071 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
8072 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
8073 addrmap to help ensure it has an accurate map of pc values belonging to
8075 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
8077 cust
= end_symtab_from_static_block (static_block
,
8078 SECT_OFF_TEXT (objfile
), 0);
8082 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
8084 /* Set symtab language to language from DW_AT_language. If the
8085 compilation is from a C file generated by language preprocessors, do
8086 not set the language if it was already deduced by start_subfile. */
8087 if (!(cu
->language
== language_c
8088 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
8089 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8091 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
8092 produce DW_AT_location with location lists but it can be possibly
8093 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
8094 there were bugs in prologue debug info, fixed later in GCC-4.5
8095 by "unwind info for epilogues" patch (which is not directly related).
8097 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
8098 needed, it would be wrong due to missing DW_AT_producer there.
8100 Still one can confuse GDB by using non-standard GCC compilation
8101 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
8103 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
8104 cust
->locations_valid
= 1;
8106 if (gcc_4_minor
>= 5)
8107 cust
->epilogue_unwind_valid
= 1;
8109 cust
->call_site_htab
= cu
->call_site_htab
;
8112 if (dwarf2_per_objfile
->using_index
)
8113 per_cu
->v
.quick
->compunit_symtab
= cust
;
8116 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8117 pst
->compunit_symtab
= cust
;
8121 /* Push it for inclusion processing later. */
8122 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
8124 do_cleanups (back_to
);
8127 /* Generate full symbol information for type unit PER_CU, whose DIEs have
8128 already been loaded into memory. */
8131 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
8132 enum language pretend_language
)
8134 struct dwarf2_cu
*cu
= per_cu
->cu
;
8135 struct objfile
*objfile
= per_cu
->objfile
;
8136 struct compunit_symtab
*cust
;
8137 struct cleanup
*back_to
, *delayed_list_cleanup
;
8138 struct signatured_type
*sig_type
;
8140 gdb_assert (per_cu
->is_debug_types
);
8141 sig_type
= (struct signatured_type
*) per_cu
;
8144 back_to
= make_cleanup (really_free_pendings
, NULL
);
8145 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
8147 cu
->list_in_scope
= &file_symbols
;
8149 cu
->language
= pretend_language
;
8150 cu
->language_defn
= language_def (cu
->language
);
8152 /* The symbol tables are set up in read_type_unit_scope. */
8153 process_die (cu
->dies
, cu
);
8155 /* For now fudge the Go package. */
8156 if (cu
->language
== language_go
)
8157 fixup_go_packaging (cu
);
8159 /* Now that we have processed all the DIEs in the CU, all the types
8160 should be complete, and it should now be safe to compute all of the
8162 compute_delayed_physnames (cu
);
8163 do_cleanups (delayed_list_cleanup
);
8165 /* TUs share symbol tables.
8166 If this is the first TU to use this symtab, complete the construction
8167 of it with end_expandable_symtab. Otherwise, complete the addition of
8168 this TU's symbols to the existing symtab. */
8169 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
8171 cust
= end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
8172 sig_type
->type_unit_group
->compunit_symtab
= cust
;
8176 /* Set symtab language to language from DW_AT_language. If the
8177 compilation is from a C file generated by language preprocessors,
8178 do not set the language if it was already deduced by
8180 if (!(cu
->language
== language_c
8181 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
8182 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
8187 augment_type_symtab ();
8188 cust
= sig_type
->type_unit_group
->compunit_symtab
;
8191 if (dwarf2_per_objfile
->using_index
)
8192 per_cu
->v
.quick
->compunit_symtab
= cust
;
8195 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8196 pst
->compunit_symtab
= cust
;
8200 do_cleanups (back_to
);
8203 /* Process an imported unit DIE. */
8206 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8208 struct attribute
*attr
;
8210 /* For now we don't handle imported units in type units. */
8211 if (cu
->per_cu
->is_debug_types
)
8213 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8214 " supported in type units [in module %s]"),
8215 objfile_name (cu
->objfile
));
8218 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8221 struct dwarf2_per_cu_data
*per_cu
;
8222 struct symtab
*imported_symtab
;
8226 offset
= dwarf2_get_ref_die_offset (attr
);
8227 is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
8228 per_cu
= dwarf2_find_containing_comp_unit (offset
, is_dwz
, cu
->objfile
);
8230 /* If necessary, add it to the queue and load its DIEs. */
8231 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
8232 load_full_comp_unit (per_cu
, cu
->language
);
8234 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8239 /* Reset the in_process bit of a die. */
8242 reset_die_in_process (void *arg
)
8244 struct die_info
*die
= arg
;
8246 die
->in_process
= 0;
8249 /* Process a die and its children. */
8252 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8254 struct cleanup
*in_process
;
8256 /* We should only be processing those not already in process. */
8257 gdb_assert (!die
->in_process
);
8259 die
->in_process
= 1;
8260 in_process
= make_cleanup (reset_die_in_process
,die
);
8264 case DW_TAG_padding
:
8266 case DW_TAG_compile_unit
:
8267 case DW_TAG_partial_unit
:
8268 read_file_scope (die
, cu
);
8270 case DW_TAG_type_unit
:
8271 read_type_unit_scope (die
, cu
);
8273 case DW_TAG_subprogram
:
8274 case DW_TAG_inlined_subroutine
:
8275 read_func_scope (die
, cu
);
8277 case DW_TAG_lexical_block
:
8278 case DW_TAG_try_block
:
8279 case DW_TAG_catch_block
:
8280 read_lexical_block_scope (die
, cu
);
8282 case DW_TAG_GNU_call_site
:
8283 read_call_site_scope (die
, cu
);
8285 case DW_TAG_class_type
:
8286 case DW_TAG_interface_type
:
8287 case DW_TAG_structure_type
:
8288 case DW_TAG_union_type
:
8289 process_structure_scope (die
, cu
);
8291 case DW_TAG_enumeration_type
:
8292 process_enumeration_scope (die
, cu
);
8295 /* These dies have a type, but processing them does not create
8296 a symbol or recurse to process the children. Therefore we can
8297 read them on-demand through read_type_die. */
8298 case DW_TAG_subroutine_type
:
8299 case DW_TAG_set_type
:
8300 case DW_TAG_array_type
:
8301 case DW_TAG_pointer_type
:
8302 case DW_TAG_ptr_to_member_type
:
8303 case DW_TAG_reference_type
:
8304 case DW_TAG_string_type
:
8307 case DW_TAG_base_type
:
8308 case DW_TAG_subrange_type
:
8309 case DW_TAG_typedef
:
8310 /* Add a typedef symbol for the type definition, if it has a
8312 new_symbol (die
, read_type_die (die
, cu
), cu
);
8314 case DW_TAG_common_block
:
8315 read_common_block (die
, cu
);
8317 case DW_TAG_common_inclusion
:
8319 case DW_TAG_namespace
:
8320 cu
->processing_has_namespace_info
= 1;
8321 read_namespace (die
, cu
);
8324 cu
->processing_has_namespace_info
= 1;
8325 read_module (die
, cu
);
8327 case DW_TAG_imported_declaration
:
8328 cu
->processing_has_namespace_info
= 1;
8329 if (read_namespace_alias (die
, cu
))
8331 /* The declaration is not a global namespace alias: fall through. */
8332 case DW_TAG_imported_module
:
8333 cu
->processing_has_namespace_info
= 1;
8334 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
8335 || cu
->language
!= language_fortran
))
8336 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
8337 dwarf_tag_name (die
->tag
));
8338 read_import_statement (die
, cu
);
8341 case DW_TAG_imported_unit
:
8342 process_imported_unit_die (die
, cu
);
8346 new_symbol (die
, NULL
, cu
);
8350 do_cleanups (in_process
);
8353 /* DWARF name computation. */
8355 /* A helper function for dwarf2_compute_name which determines whether DIE
8356 needs to have the name of the scope prepended to the name listed in the
8360 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8362 struct attribute
*attr
;
8366 case DW_TAG_namespace
:
8367 case DW_TAG_typedef
:
8368 case DW_TAG_class_type
:
8369 case DW_TAG_interface_type
:
8370 case DW_TAG_structure_type
:
8371 case DW_TAG_union_type
:
8372 case DW_TAG_enumeration_type
:
8373 case DW_TAG_enumerator
:
8374 case DW_TAG_subprogram
:
8375 case DW_TAG_inlined_subroutine
:
8377 case DW_TAG_imported_declaration
:
8380 case DW_TAG_variable
:
8381 case DW_TAG_constant
:
8382 /* We only need to prefix "globally" visible variables. These include
8383 any variable marked with DW_AT_external or any variable that
8384 lives in a namespace. [Variables in anonymous namespaces
8385 require prefixing, but they are not DW_AT_external.] */
8387 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
8389 struct dwarf2_cu
*spec_cu
= cu
;
8391 return die_needs_namespace (die_specification (die
, &spec_cu
),
8395 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
8396 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
8397 && die
->parent
->tag
!= DW_TAG_module
)
8399 /* A variable in a lexical block of some kind does not need a
8400 namespace, even though in C++ such variables may be external
8401 and have a mangled name. */
8402 if (die
->parent
->tag
== DW_TAG_lexical_block
8403 || die
->parent
->tag
== DW_TAG_try_block
8404 || die
->parent
->tag
== DW_TAG_catch_block
8405 || die
->parent
->tag
== DW_TAG_subprogram
)
8414 /* Retrieve the last character from a mem_file. */
8417 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
8419 char *last_char_p
= (char *) object
;
8422 *last_char_p
= buffer
[length
- 1];
8425 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8426 compute the physname for the object, which include a method's:
8427 - formal parameters (C++/Java),
8428 - receiver type (Go),
8429 - return type (Java).
8431 The term "physname" is a bit confusing.
8432 For C++, for example, it is the demangled name.
8433 For Go, for example, it's the mangled name.
8435 For Ada, return the DIE's linkage name rather than the fully qualified
8436 name. PHYSNAME is ignored..
8438 The result is allocated on the objfile_obstack and canonicalized. */
8441 dwarf2_compute_name (const char *name
,
8442 struct die_info
*die
, struct dwarf2_cu
*cu
,
8445 struct objfile
*objfile
= cu
->objfile
;
8448 name
= dwarf2_name (die
, cu
);
8450 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8451 compute it by typename_concat inside GDB. */
8452 if (cu
->language
== language_ada
8453 || (cu
->language
== language_fortran
&& physname
))
8455 /* For Ada unit, we prefer the linkage name over the name, as
8456 the former contains the exported name, which the user expects
8457 to be able to reference. Ideally, we want the user to be able
8458 to reference this entity using either natural or linkage name,
8459 but we haven't started looking at this enhancement yet. */
8460 struct attribute
*attr
;
8462 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8464 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8465 if (attr
&& DW_STRING (attr
))
8466 return DW_STRING (attr
);
8469 /* These are the only languages we know how to qualify names in. */
8471 && (cu
->language
== language_cplus
|| cu
->language
== language_java
8472 || cu
->language
== language_fortran
|| cu
->language
== language_d
))
8474 if (die_needs_namespace (die
, cu
))
8478 struct ui_file
*buf
;
8479 char *intermediate_name
;
8480 const char *canonical_name
= NULL
;
8482 prefix
= determine_prefix (die
, cu
);
8483 buf
= mem_fileopen ();
8484 if (*prefix
!= '\0')
8486 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
8489 fputs_unfiltered (prefixed_name
, buf
);
8490 xfree (prefixed_name
);
8493 fputs_unfiltered (name
, buf
);
8495 /* Template parameters may be specified in the DIE's DW_AT_name, or
8496 as children with DW_TAG_template_type_param or
8497 DW_TAG_value_type_param. If the latter, add them to the name
8498 here. If the name already has template parameters, then
8499 skip this step; some versions of GCC emit both, and
8500 it is more efficient to use the pre-computed name.
8502 Something to keep in mind about this process: it is very
8503 unlikely, or in some cases downright impossible, to produce
8504 something that will match the mangled name of a function.
8505 If the definition of the function has the same debug info,
8506 we should be able to match up with it anyway. But fallbacks
8507 using the minimal symbol, for instance to find a method
8508 implemented in a stripped copy of libstdc++, will not work.
8509 If we do not have debug info for the definition, we will have to
8510 match them up some other way.
8512 When we do name matching there is a related problem with function
8513 templates; two instantiated function templates are allowed to
8514 differ only by their return types, which we do not add here. */
8516 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
8518 struct attribute
*attr
;
8519 struct die_info
*child
;
8522 die
->building_fullname
= 1;
8524 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
8528 const gdb_byte
*bytes
;
8529 struct dwarf2_locexpr_baton
*baton
;
8532 if (child
->tag
!= DW_TAG_template_type_param
8533 && child
->tag
!= DW_TAG_template_value_param
)
8538 fputs_unfiltered ("<", buf
);
8542 fputs_unfiltered (", ", buf
);
8544 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
8547 complaint (&symfile_complaints
,
8548 _("template parameter missing DW_AT_type"));
8549 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
8552 type
= die_type (child
, cu
);
8554 if (child
->tag
== DW_TAG_template_type_param
)
8556 c_print_type (type
, "", buf
, -1, 0, &type_print_raw_options
);
8560 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
8563 complaint (&symfile_complaints
,
8564 _("template parameter missing "
8565 "DW_AT_const_value"));
8566 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
8570 dwarf2_const_value_attr (attr
, type
, name
,
8571 &cu
->comp_unit_obstack
, cu
,
8572 &value
, &bytes
, &baton
);
8574 if (TYPE_NOSIGN (type
))
8575 /* GDB prints characters as NUMBER 'CHAR'. If that's
8576 changed, this can use value_print instead. */
8577 c_printchar (value
, type
, buf
);
8580 struct value_print_options opts
;
8583 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
8587 else if (bytes
!= NULL
)
8589 v
= allocate_value (type
);
8590 memcpy (value_contents_writeable (v
), bytes
,
8591 TYPE_LENGTH (type
));
8594 v
= value_from_longest (type
, value
);
8596 /* Specify decimal so that we do not depend on
8598 get_formatted_print_options (&opts
, 'd');
8600 value_print (v
, buf
, &opts
);
8606 die
->building_fullname
= 0;
8610 /* Close the argument list, with a space if necessary
8611 (nested templates). */
8612 char last_char
= '\0';
8613 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
8614 if (last_char
== '>')
8615 fputs_unfiltered (" >", buf
);
8617 fputs_unfiltered (">", buf
);
8621 /* For Java and C++ methods, append formal parameter type
8622 information, if PHYSNAME. */
8624 if (physname
&& die
->tag
== DW_TAG_subprogram
8625 && (cu
->language
== language_cplus
8626 || cu
->language
== language_java
))
8628 struct type
*type
= read_type_die (die
, cu
);
8630 c_type_print_args (type
, buf
, 1, cu
->language
,
8631 &type_print_raw_options
);
8633 if (cu
->language
== language_java
)
8635 /* For java, we must append the return type to method
8637 if (die
->tag
== DW_TAG_subprogram
)
8638 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
8639 0, 0, &type_print_raw_options
);
8641 else if (cu
->language
== language_cplus
)
8643 /* Assume that an artificial first parameter is
8644 "this", but do not crash if it is not. RealView
8645 marks unnamed (and thus unused) parameters as
8646 artificial; there is no way to differentiate
8648 if (TYPE_NFIELDS (type
) > 0
8649 && TYPE_FIELD_ARTIFICIAL (type
, 0)
8650 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
8651 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
8653 fputs_unfiltered (" const", buf
);
8657 intermediate_name
= ui_file_xstrdup (buf
, &length
);
8658 ui_file_delete (buf
);
8660 if (cu
->language
== language_cplus
)
8662 = dwarf2_canonicalize_name (intermediate_name
, cu
,
8663 &objfile
->per_bfd
->storage_obstack
);
8665 /* If we only computed INTERMEDIATE_NAME, or if
8666 INTERMEDIATE_NAME is already canonical, then we need to
8667 copy it to the appropriate obstack. */
8668 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
)
8669 name
= obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8671 strlen (intermediate_name
));
8673 name
= canonical_name
;
8675 xfree (intermediate_name
);
8682 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8683 If scope qualifiers are appropriate they will be added. The result
8684 will be allocated on the storage_obstack, or NULL if the DIE does
8685 not have a name. NAME may either be from a previous call to
8686 dwarf2_name or NULL.
8688 The output string will be canonicalized (if C++/Java). */
8691 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8693 return dwarf2_compute_name (name
, die
, cu
, 0);
8696 /* Construct a physname for the given DIE in CU. NAME may either be
8697 from a previous call to dwarf2_name or NULL. The result will be
8698 allocated on the objfile_objstack or NULL if the DIE does not have a
8701 The output string will be canonicalized (if C++/Java). */
8704 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
8706 struct objfile
*objfile
= cu
->objfile
;
8707 struct attribute
*attr
;
8708 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
8709 struct cleanup
*back_to
;
8712 /* In this case dwarf2_compute_name is just a shortcut not building anything
8714 if (!die_needs_namespace (die
, cu
))
8715 return dwarf2_compute_name (name
, die
, cu
, 1);
8717 back_to
= make_cleanup (null_cleanup
, NULL
);
8719 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
8721 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8723 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8725 if (attr
&& DW_STRING (attr
))
8729 mangled
= DW_STRING (attr
);
8731 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8732 type. It is easier for GDB users to search for such functions as
8733 `name(params)' than `long name(params)'. In such case the minimal
8734 symbol names do not match the full symbol names but for template
8735 functions there is never a need to look up their definition from their
8736 declaration so the only disadvantage remains the minimal symbol
8737 variant `long name(params)' does not have the proper inferior type.
8740 if (cu
->language
== language_go
)
8742 /* This is a lie, but we already lie to the caller new_symbol_full.
8743 new_symbol_full assumes we return the mangled name.
8744 This just undoes that lie until things are cleaned up. */
8749 demangled
= gdb_demangle (mangled
,
8750 (DMGL_PARAMS
| DMGL_ANSI
8751 | (cu
->language
== language_java
8752 ? DMGL_JAVA
| DMGL_RET_POSTFIX
8757 make_cleanup (xfree
, demangled
);
8767 if (canon
== NULL
|| check_physname
)
8769 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
8771 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
8773 /* It may not mean a bug in GDB. The compiler could also
8774 compute DW_AT_linkage_name incorrectly. But in such case
8775 GDB would need to be bug-to-bug compatible. */
8777 complaint (&symfile_complaints
,
8778 _("Computed physname <%s> does not match demangled <%s> "
8779 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8780 physname
, canon
, mangled
, die
->offset
.sect_off
,
8781 objfile_name (objfile
));
8783 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8784 is available here - over computed PHYSNAME. It is safer
8785 against both buggy GDB and buggy compilers. */
8799 retval
= obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
8800 retval
, strlen (retval
));
8802 do_cleanups (back_to
);
8806 /* Inspect DIE in CU for a namespace alias. If one exists, record
8807 a new symbol for it.
8809 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8812 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
8814 struct attribute
*attr
;
8816 /* If the die does not have a name, this is not a namespace
8818 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8822 struct die_info
*d
= die
;
8823 struct dwarf2_cu
*imported_cu
= cu
;
8825 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8826 keep inspecting DIEs until we hit the underlying import. */
8827 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8828 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
8830 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
8834 d
= follow_die_ref (d
, attr
, &imported_cu
);
8835 if (d
->tag
!= DW_TAG_imported_declaration
)
8839 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
8841 complaint (&symfile_complaints
,
8842 _("DIE at 0x%x has too many recursively imported "
8843 "declarations"), d
->offset
.sect_off
);
8850 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
8852 type
= get_die_type_at_offset (offset
, cu
->per_cu
);
8853 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
8855 /* This declaration is a global namespace alias. Add
8856 a symbol for it whose type is the aliased namespace. */
8857 new_symbol (die
, type
, cu
);
8866 /* Read the import statement specified by the given die and record it. */
8869 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
8871 struct objfile
*objfile
= cu
->objfile
;
8872 struct attribute
*import_attr
;
8873 struct die_info
*imported_die
, *child_die
;
8874 struct dwarf2_cu
*imported_cu
;
8875 const char *imported_name
;
8876 const char *imported_name_prefix
;
8877 const char *canonical_name
;
8878 const char *import_alias
;
8879 const char *imported_declaration
= NULL
;
8880 const char *import_prefix
;
8881 VEC (const_char_ptr
) *excludes
= NULL
;
8882 struct cleanup
*cleanups
;
8884 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
8885 if (import_attr
== NULL
)
8887 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8888 dwarf_tag_name (die
->tag
));
8893 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
8894 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8895 if (imported_name
== NULL
)
8897 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8899 The import in the following code:
8913 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8914 <52> DW_AT_decl_file : 1
8915 <53> DW_AT_decl_line : 6
8916 <54> DW_AT_import : <0x75>
8917 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8919 <5b> DW_AT_decl_file : 1
8920 <5c> DW_AT_decl_line : 2
8921 <5d> DW_AT_type : <0x6e>
8923 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8924 <76> DW_AT_byte_size : 4
8925 <77> DW_AT_encoding : 5 (signed)
8927 imports the wrong die ( 0x75 instead of 0x58 ).
8928 This case will be ignored until the gcc bug is fixed. */
8932 /* Figure out the local name after import. */
8933 import_alias
= dwarf2_name (die
, cu
);
8935 /* Figure out where the statement is being imported to. */
8936 import_prefix
= determine_prefix (die
, cu
);
8938 /* Figure out what the scope of the imported die is and prepend it
8939 to the name of the imported die. */
8940 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
8942 if (imported_die
->tag
!= DW_TAG_namespace
8943 && imported_die
->tag
!= DW_TAG_module
)
8945 imported_declaration
= imported_name
;
8946 canonical_name
= imported_name_prefix
;
8948 else if (strlen (imported_name_prefix
) > 0)
8949 canonical_name
= obconcat (&objfile
->objfile_obstack
,
8950 imported_name_prefix
,
8951 (cu
->language
== language_d
? "." : "::"),
8952 imported_name
, (char *) NULL
);
8954 canonical_name
= imported_name
;
8956 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
8958 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
8959 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
8960 child_die
= sibling_die (child_die
))
8962 /* DWARF-4: A Fortran use statement with a “rename list” may be
8963 represented by an imported module entry with an import attribute
8964 referring to the module and owned entries corresponding to those
8965 entities that are renamed as part of being imported. */
8967 if (child_die
->tag
!= DW_TAG_imported_declaration
)
8969 complaint (&symfile_complaints
,
8970 _("child DW_TAG_imported_declaration expected "
8971 "- DIE at 0x%x [in module %s]"),
8972 child_die
->offset
.sect_off
, objfile_name (objfile
));
8976 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
8977 if (import_attr
== NULL
)
8979 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
8980 dwarf_tag_name (child_die
->tag
));
8985 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
8987 imported_name
= dwarf2_name (imported_die
, imported_cu
);
8988 if (imported_name
== NULL
)
8990 complaint (&symfile_complaints
,
8991 _("child DW_TAG_imported_declaration has unknown "
8992 "imported name - DIE at 0x%x [in module %s]"),
8993 child_die
->offset
.sect_off
, objfile_name (objfile
));
8997 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
8999 process_die (child_die
, cu
);
9002 cp_add_using_directive (import_prefix
,
9005 imported_declaration
,
9008 &objfile
->objfile_obstack
);
9010 do_cleanups (cleanups
);
9013 /* Cleanup function for handle_DW_AT_stmt_list. */
9016 free_cu_line_header (void *arg
)
9018 struct dwarf2_cu
*cu
= arg
;
9020 free_line_header (cu
->line_header
);
9021 cu
->line_header
= NULL
;
9024 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
9025 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
9026 this, it was first present in GCC release 4.3.0. */
9029 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
9031 if (!cu
->checked_producer
)
9032 check_producer (cu
);
9034 return cu
->producer_is_gcc_lt_4_3
;
9038 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
9039 const char **name
, const char **comp_dir
)
9041 struct attribute
*attr
;
9046 /* Find the filename. Do not use dwarf2_name here, since the filename
9047 is not a source language identifier. */
9048 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
9051 *name
= DW_STRING (attr
);
9054 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
9056 *comp_dir
= DW_STRING (attr
);
9057 else if (producer_is_gcc_lt_4_3 (cu
) && *name
!= NULL
9058 && IS_ABSOLUTE_PATH (*name
))
9060 char *d
= ldirname (*name
);
9064 make_cleanup (xfree
, d
);
9066 if (*comp_dir
!= NULL
)
9068 /* Irix 6.2 native cc prepends <machine>.: to the compilation
9069 directory, get rid of it. */
9070 char *cp
= strchr (*comp_dir
, ':');
9072 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
9077 *name
= "<unknown>";
9080 /* Handle DW_AT_stmt_list for a compilation unit.
9081 DIE is the DW_TAG_compile_unit die for CU.
9082 COMP_DIR is the compilation directory. LOWPC is passed to
9083 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
9086 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
9087 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
9089 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9090 struct attribute
*attr
;
9091 unsigned int line_offset
;
9092 struct line_header line_header_local
;
9093 hashval_t line_header_local_hash
;
9098 gdb_assert (! cu
->per_cu
->is_debug_types
);
9100 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9104 line_offset
= DW_UNSND (attr
);
9106 /* The line header hash table is only created if needed (it exists to
9107 prevent redundant reading of the line table for partial_units).
9108 If we're given a partial_unit, we'll need it. If we're given a
9109 compile_unit, then use the line header hash table if it's already
9110 created, but don't create one just yet. */
9112 if (dwarf2_per_objfile
->line_header_hash
== NULL
9113 && die
->tag
== DW_TAG_partial_unit
)
9115 dwarf2_per_objfile
->line_header_hash
9116 = htab_create_alloc_ex (127, line_header_hash_voidp
,
9117 line_header_eq_voidp
,
9118 free_line_header_voidp
,
9119 &objfile
->objfile_obstack
,
9120 hashtab_obstack_allocate
,
9121 dummy_obstack_deallocate
);
9124 line_header_local
.offset
.sect_off
= line_offset
;
9125 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
9126 line_header_local_hash
= line_header_hash (&line_header_local
);
9127 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
9129 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9131 line_header_local_hash
, NO_INSERT
);
9133 /* For DW_TAG_compile_unit we need info like symtab::linetable which
9134 is not present in *SLOT (since if there is something in *SLOT then
9135 it will be for a partial_unit). */
9136 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
9138 gdb_assert (*slot
!= NULL
);
9139 cu
->line_header
= *slot
;
9144 /* dwarf_decode_line_header does not yet provide sufficient information.
9145 We always have to call also dwarf_decode_lines for it. */
9146 cu
->line_header
= dwarf_decode_line_header (line_offset
, cu
);
9147 if (cu
->line_header
== NULL
)
9150 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
9154 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
9156 line_header_local_hash
, INSERT
);
9157 gdb_assert (slot
!= NULL
);
9159 if (slot
!= NULL
&& *slot
== NULL
)
9161 /* This newly decoded line number information unit will be owned
9162 by line_header_hash hash table. */
9163 *slot
= cu
->line_header
;
9167 /* We cannot free any current entry in (*slot) as that struct line_header
9168 may be already used by multiple CUs. Create only temporary decoded
9169 line_header for this CU - it may happen at most once for each line
9170 number information unit. And if we're not using line_header_hash
9171 then this is what we want as well. */
9172 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
9173 make_cleanup (free_cu_line_header
, cu
);
9175 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
9176 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
9180 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
9183 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9185 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9186 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9187 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
9188 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
9189 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
9190 struct attribute
*attr
;
9191 const char *name
= NULL
;
9192 const char *comp_dir
= NULL
;
9193 struct die_info
*child_die
;
9194 bfd
*abfd
= objfile
->obfd
;
9197 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9199 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
9201 /* If we didn't find a lowpc, set it to highpc to avoid complaints
9202 from finish_block. */
9203 if (lowpc
== ((CORE_ADDR
) -1))
9205 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
9207 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
9209 prepare_one_comp_unit (cu
, die
, cu
->language
);
9211 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
9212 standardised yet. As a workaround for the language detection we fall
9213 back to the DW_AT_producer string. */
9214 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
9215 cu
->language
= language_opencl
;
9217 /* Similar hack for Go. */
9218 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
9219 set_cu_language (DW_LANG_Go
, cu
);
9221 dwarf2_start_symtab (cu
, name
, comp_dir
, lowpc
);
9223 /* Decode line number information if present. We do this before
9224 processing child DIEs, so that the line header table is available
9225 for DW_AT_decl_file. */
9226 handle_DW_AT_stmt_list (die
, cu
, comp_dir
, lowpc
);
9228 /* Process all dies in compilation unit. */
9229 if (die
->child
!= NULL
)
9231 child_die
= die
->child
;
9232 while (child_die
&& child_die
->tag
)
9234 process_die (child_die
, cu
);
9235 child_die
= sibling_die (child_die
);
9239 /* Decode macro information, if present. Dwarf 2 macro information
9240 refers to information in the line number info statement program
9241 header, so we can only read it if we've read the header
9243 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
9244 if (attr
&& cu
->line_header
)
9246 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
9247 complaint (&symfile_complaints
,
9248 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
9250 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
9254 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
9255 if (attr
&& cu
->line_header
)
9257 unsigned int macro_offset
= DW_UNSND (attr
);
9259 dwarf_decode_macros (cu
, macro_offset
, 0);
9263 do_cleanups (back_to
);
9266 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
9267 Create the set of symtabs used by this TU, or if this TU is sharing
9268 symtabs with another TU and the symtabs have already been created
9269 then restore those symtabs in the line header.
9270 We don't need the pc/line-number mapping for type units. */
9273 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
9275 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9276 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
9277 struct type_unit_group
*tu_group
;
9279 struct line_header
*lh
;
9280 struct attribute
*attr
;
9281 unsigned int i
, line_offset
;
9282 struct signatured_type
*sig_type
;
9284 gdb_assert (per_cu
->is_debug_types
);
9285 sig_type
= (struct signatured_type
*) per_cu
;
9287 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
9289 /* If we're using .gdb_index (includes -readnow) then
9290 per_cu->type_unit_group may not have been set up yet. */
9291 if (sig_type
->type_unit_group
== NULL
)
9292 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
9293 tu_group
= sig_type
->type_unit_group
;
9295 /* If we've already processed this stmt_list there's no real need to
9296 do it again, we could fake it and just recreate the part we need
9297 (file name,index -> symtab mapping). If data shows this optimization
9298 is useful we can do it then. */
9299 first_time
= tu_group
->compunit_symtab
== NULL
;
9301 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9306 line_offset
= DW_UNSND (attr
);
9307 lh
= dwarf_decode_line_header (line_offset
, cu
);
9312 dwarf2_start_symtab (cu
, "", NULL
, 0);
9315 gdb_assert (tu_group
->symtabs
== NULL
);
9316 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9321 cu
->line_header
= lh
;
9322 make_cleanup (free_cu_line_header
, cu
);
9326 struct compunit_symtab
*cust
= dwarf2_start_symtab (cu
, "", NULL
, 0);
9328 tu_group
->num_symtabs
= lh
->num_file_names
;
9329 tu_group
->symtabs
= XNEWVEC (struct symtab
*, lh
->num_file_names
);
9331 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9333 const char *dir
= NULL
;
9334 struct file_entry
*fe
= &lh
->file_names
[i
];
9336 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
9337 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9338 dwarf2_start_subfile (fe
->name
, dir
);
9340 if (current_subfile
->symtab
== NULL
)
9342 /* NOTE: start_subfile will recognize when it's been passed
9343 a file it has already seen. So we can't assume there's a
9344 simple mapping from lh->file_names to subfiles, plus
9345 lh->file_names may contain dups. */
9346 current_subfile
->symtab
9347 = allocate_symtab (cust
, current_subfile
->name
);
9350 fe
->symtab
= current_subfile
->symtab
;
9351 tu_group
->symtabs
[i
] = fe
->symtab
;
9356 restart_symtab (tu_group
->compunit_symtab
, "", 0);
9358 for (i
= 0; i
< lh
->num_file_names
; ++i
)
9360 struct file_entry
*fe
= &lh
->file_names
[i
];
9362 fe
->symtab
= tu_group
->symtabs
[i
];
9366 /* The main symtab is allocated last. Type units don't have DW_AT_name
9367 so they don't have a "real" (so to speak) symtab anyway.
9368 There is later code that will assign the main symtab to all symbols
9369 that don't have one. We need to handle the case of a symbol with a
9370 missing symtab (DW_AT_decl_file) anyway. */
9373 /* Process DW_TAG_type_unit.
9374 For TUs we want to skip the first top level sibling if it's not the
9375 actual type being defined by this TU. In this case the first top
9376 level sibling is there to provide context only. */
9379 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9381 struct die_info
*child_die
;
9383 prepare_one_comp_unit (cu
, die
, language_minimal
);
9385 /* Initialize (or reinitialize) the machinery for building symtabs.
9386 We do this before processing child DIEs, so that the line header table
9387 is available for DW_AT_decl_file. */
9388 setup_type_unit_groups (die
, cu
);
9390 if (die
->child
!= NULL
)
9392 child_die
= die
->child
;
9393 while (child_die
&& child_die
->tag
)
9395 process_die (child_die
, cu
);
9396 child_die
= sibling_die (child_die
);
9403 http://gcc.gnu.org/wiki/DebugFission
9404 http://gcc.gnu.org/wiki/DebugFissionDWP
9406 To simplify handling of both DWO files ("object" files with the DWARF info)
9407 and DWP files (a file with the DWOs packaged up into one file), we treat
9408 DWP files as having a collection of virtual DWO files. */
9411 hash_dwo_file (const void *item
)
9413 const struct dwo_file
*dwo_file
= item
;
9416 hash
= htab_hash_string (dwo_file
->dwo_name
);
9417 if (dwo_file
->comp_dir
!= NULL
)
9418 hash
+= htab_hash_string (dwo_file
->comp_dir
);
9423 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
9425 const struct dwo_file
*lhs
= item_lhs
;
9426 const struct dwo_file
*rhs
= item_rhs
;
9428 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
9430 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
9431 return lhs
->comp_dir
== rhs
->comp_dir
;
9432 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
9435 /* Allocate a hash table for DWO files. */
9438 allocate_dwo_file_hash_table (void)
9440 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9442 return htab_create_alloc_ex (41,
9446 &objfile
->objfile_obstack
,
9447 hashtab_obstack_allocate
,
9448 dummy_obstack_deallocate
);
9451 /* Lookup DWO file DWO_NAME. */
9454 lookup_dwo_file_slot (const char *dwo_name
, const char *comp_dir
)
9456 struct dwo_file find_entry
;
9459 if (dwarf2_per_objfile
->dwo_files
== NULL
)
9460 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
9462 memset (&find_entry
, 0, sizeof (find_entry
));
9463 find_entry
.dwo_name
= dwo_name
;
9464 find_entry
.comp_dir
= comp_dir
;
9465 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
9471 hash_dwo_unit (const void *item
)
9473 const struct dwo_unit
*dwo_unit
= item
;
9475 /* This drops the top 32 bits of the id, but is ok for a hash. */
9476 return dwo_unit
->signature
;
9480 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
9482 const struct dwo_unit
*lhs
= item_lhs
;
9483 const struct dwo_unit
*rhs
= item_rhs
;
9485 /* The signature is assumed to be unique within the DWO file.
9486 So while object file CU dwo_id's always have the value zero,
9487 that's OK, assuming each object file DWO file has only one CU,
9488 and that's the rule for now. */
9489 return lhs
->signature
== rhs
->signature
;
9492 /* Allocate a hash table for DWO CUs,TUs.
9493 There is one of these tables for each of CUs,TUs for each DWO file. */
9496 allocate_dwo_unit_table (struct objfile
*objfile
)
9498 /* Start out with a pretty small number.
9499 Generally DWO files contain only one CU and maybe some TUs. */
9500 return htab_create_alloc_ex (3,
9504 &objfile
->objfile_obstack
,
9505 hashtab_obstack_allocate
,
9506 dummy_obstack_deallocate
);
9509 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9511 struct create_dwo_cu_data
9513 struct dwo_file
*dwo_file
;
9514 struct dwo_unit dwo_unit
;
9517 /* die_reader_func for create_dwo_cu. */
9520 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
9521 const gdb_byte
*info_ptr
,
9522 struct die_info
*comp_unit_die
,
9526 struct dwarf2_cu
*cu
= reader
->cu
;
9527 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9528 sect_offset offset
= cu
->per_cu
->offset
;
9529 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
9530 struct create_dwo_cu_data
*data
= datap
;
9531 struct dwo_file
*dwo_file
= data
->dwo_file
;
9532 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
9533 struct attribute
*attr
;
9535 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
9538 complaint (&symfile_complaints
,
9539 _("Dwarf Error: debug entry at offset 0x%x is missing"
9540 " its dwo_id [in module %s]"),
9541 offset
.sect_off
, dwo_file
->dwo_name
);
9545 dwo_unit
->dwo_file
= dwo_file
;
9546 dwo_unit
->signature
= DW_UNSND (attr
);
9547 dwo_unit
->section
= section
;
9548 dwo_unit
->offset
= offset
;
9549 dwo_unit
->length
= cu
->per_cu
->length
;
9551 if (dwarf_read_debug
)
9552 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id %s\n",
9553 offset
.sect_off
, hex_string (dwo_unit
->signature
));
9556 /* Create the dwo_unit for the lone CU in DWO_FILE.
9557 Note: This function processes DWO files only, not DWP files. */
9559 static struct dwo_unit
*
9560 create_dwo_cu (struct dwo_file
*dwo_file
)
9562 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9563 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
9566 const gdb_byte
*info_ptr
, *end_ptr
;
9567 struct create_dwo_cu_data create_dwo_cu_data
;
9568 struct dwo_unit
*dwo_unit
;
9570 dwarf2_read_section (objfile
, section
);
9571 info_ptr
= section
->buffer
;
9573 if (info_ptr
== NULL
)
9576 /* We can't set abfd until now because the section may be empty or
9577 not present, in which case section->asection will be NULL. */
9578 abfd
= get_section_bfd_owner (section
);
9580 if (dwarf_read_debug
)
9582 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
9583 get_section_name (section
),
9584 get_section_file_name (section
));
9587 create_dwo_cu_data
.dwo_file
= dwo_file
;
9590 end_ptr
= info_ptr
+ section
->size
;
9591 while (info_ptr
< end_ptr
)
9593 struct dwarf2_per_cu_data per_cu
;
9595 memset (&create_dwo_cu_data
.dwo_unit
, 0,
9596 sizeof (create_dwo_cu_data
.dwo_unit
));
9597 memset (&per_cu
, 0, sizeof (per_cu
));
9598 per_cu
.objfile
= objfile
;
9599 per_cu
.is_debug_types
= 0;
9600 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
9601 per_cu
.section
= section
;
9603 init_cutu_and_read_dies_no_follow (&per_cu
, dwo_file
,
9604 create_dwo_cu_reader
,
9605 &create_dwo_cu_data
);
9607 if (create_dwo_cu_data
.dwo_unit
.dwo_file
!= NULL
)
9609 /* If we've already found one, complain. We only support one
9610 because having more than one requires hacking the dwo_name of
9611 each to match, which is highly unlikely to happen. */
9612 if (dwo_unit
!= NULL
)
9614 complaint (&symfile_complaints
,
9615 _("Multiple CUs in DWO file %s [in module %s]"),
9616 dwo_file
->dwo_name
, objfile_name (objfile
));
9620 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
9621 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
9624 info_ptr
+= per_cu
.length
;
9630 /* DWP file .debug_{cu,tu}_index section format:
9631 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9635 Both index sections have the same format, and serve to map a 64-bit
9636 signature to a set of section numbers. Each section begins with a header,
9637 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9638 indexes, and a pool of 32-bit section numbers. The index sections will be
9639 aligned at 8-byte boundaries in the file.
9641 The index section header consists of:
9643 V, 32 bit version number
9645 N, 32 bit number of compilation units or type units in the index
9646 M, 32 bit number of slots in the hash table
9648 Numbers are recorded using the byte order of the application binary.
9650 The hash table begins at offset 16 in the section, and consists of an array
9651 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9652 order of the application binary). Unused slots in the hash table are 0.
9653 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9655 The parallel table begins immediately after the hash table
9656 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9657 array of 32-bit indexes (using the byte order of the application binary),
9658 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9659 table contains a 32-bit index into the pool of section numbers. For unused
9660 hash table slots, the corresponding entry in the parallel table will be 0.
9662 The pool of section numbers begins immediately following the hash table
9663 (at offset 16 + 12 * M from the beginning of the section). The pool of
9664 section numbers consists of an array of 32-bit words (using the byte order
9665 of the application binary). Each item in the array is indexed starting
9666 from 0. The hash table entry provides the index of the first section
9667 number in the set. Additional section numbers in the set follow, and the
9668 set is terminated by a 0 entry (section number 0 is not used in ELF).
9670 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9671 section must be the first entry in the set, and the .debug_abbrev.dwo must
9672 be the second entry. Other members of the set may follow in any order.
9678 DWP Version 2 combines all the .debug_info, etc. sections into one,
9679 and the entries in the index tables are now offsets into these sections.
9680 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9683 Index Section Contents:
9685 Hash Table of Signatures dwp_hash_table.hash_table
9686 Parallel Table of Indices dwp_hash_table.unit_table
9687 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9688 Table of Section Sizes dwp_hash_table.v2.sizes
9690 The index section header consists of:
9692 V, 32 bit version number
9693 L, 32 bit number of columns in the table of section offsets
9694 N, 32 bit number of compilation units or type units in the index
9695 M, 32 bit number of slots in the hash table
9697 Numbers are recorded using the byte order of the application binary.
9699 The hash table has the same format as version 1.
9700 The parallel table of indices has the same format as version 1,
9701 except that the entries are origin-1 indices into the table of sections
9702 offsets and the table of section sizes.
9704 The table of offsets begins immediately following the parallel table
9705 (at offset 16 + 12 * M from the beginning of the section). The table is
9706 a two-dimensional array of 32-bit words (using the byte order of the
9707 application binary), with L columns and N+1 rows, in row-major order.
9708 Each row in the array is indexed starting from 0. The first row provides
9709 a key to the remaining rows: each column in this row provides an identifier
9710 for a debug section, and the offsets in the same column of subsequent rows
9711 refer to that section. The section identifiers are:
9713 DW_SECT_INFO 1 .debug_info.dwo
9714 DW_SECT_TYPES 2 .debug_types.dwo
9715 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9716 DW_SECT_LINE 4 .debug_line.dwo
9717 DW_SECT_LOC 5 .debug_loc.dwo
9718 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9719 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9720 DW_SECT_MACRO 8 .debug_macro.dwo
9722 The offsets provided by the CU and TU index sections are the base offsets
9723 for the contributions made by each CU or TU to the corresponding section
9724 in the package file. Each CU and TU header contains an abbrev_offset
9725 field, used to find the abbreviations table for that CU or TU within the
9726 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9727 be interpreted as relative to the base offset given in the index section.
9728 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9729 should be interpreted as relative to the base offset for .debug_line.dwo,
9730 and offsets into other debug sections obtained from DWARF attributes should
9731 also be interpreted as relative to the corresponding base offset.
9733 The table of sizes begins immediately following the table of offsets.
9734 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9735 with L columns and N rows, in row-major order. Each row in the array is
9736 indexed starting from 1 (row 0 is shared by the two tables).
9740 Hash table lookup is handled the same in version 1 and 2:
9742 We assume that N and M will not exceed 2^32 - 1.
9743 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9745 Given a 64-bit compilation unit signature or a type signature S, an entry
9746 in the hash table is located as follows:
9748 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9749 the low-order k bits all set to 1.
9751 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9753 3) If the hash table entry at index H matches the signature, use that
9754 entry. If the hash table entry at index H is unused (all zeroes),
9755 terminate the search: the signature is not present in the table.
9757 4) Let H = (H + H') modulo M. Repeat at Step 3.
9759 Because M > N and H' and M are relatively prime, the search is guaranteed
9760 to stop at an unused slot or find the match. */
9762 /* Create a hash table to map DWO IDs to their CU/TU entry in
9763 .debug_{info,types}.dwo in DWP_FILE.
9764 Returns NULL if there isn't one.
9765 Note: This function processes DWP files only, not DWO files. */
9767 static struct dwp_hash_table
*
9768 create_dwp_hash_table (struct dwp_file
*dwp_file
, int is_debug_types
)
9770 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9771 bfd
*dbfd
= dwp_file
->dbfd
;
9772 const gdb_byte
*index_ptr
, *index_end
;
9773 struct dwarf2_section_info
*index
;
9774 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
9775 struct dwp_hash_table
*htab
;
9778 index
= &dwp_file
->sections
.tu_index
;
9780 index
= &dwp_file
->sections
.cu_index
;
9782 if (dwarf2_section_empty_p (index
))
9784 dwarf2_read_section (objfile
, index
);
9786 index_ptr
= index
->buffer
;
9787 index_end
= index_ptr
+ index
->size
;
9789 version
= read_4_bytes (dbfd
, index_ptr
);
9792 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
9796 nr_units
= read_4_bytes (dbfd
, index_ptr
);
9798 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
9801 if (version
!= 1 && version
!= 2)
9803 error (_("Dwarf Error: unsupported DWP file version (%s)"
9805 pulongest (version
), dwp_file
->name
);
9807 if (nr_slots
!= (nr_slots
& -nr_slots
))
9809 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9810 " is not power of 2 [in module %s]"),
9811 pulongest (nr_slots
), dwp_file
->name
);
9814 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
9815 htab
->version
= version
;
9816 htab
->nr_columns
= nr_columns
;
9817 htab
->nr_units
= nr_units
;
9818 htab
->nr_slots
= nr_slots
;
9819 htab
->hash_table
= index_ptr
;
9820 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
9822 /* Exit early if the table is empty. */
9823 if (nr_slots
== 0 || nr_units
== 0
9824 || (version
== 2 && nr_columns
== 0))
9826 /* All must be zero. */
9827 if (nr_slots
!= 0 || nr_units
!= 0
9828 || (version
== 2 && nr_columns
!= 0))
9830 complaint (&symfile_complaints
,
9831 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9832 " all zero [in modules %s]"),
9840 htab
->section_pool
.v1
.indices
=
9841 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9842 /* It's harder to decide whether the section is too small in v1.
9843 V1 is deprecated anyway so we punt. */
9847 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
9848 int *ids
= htab
->section_pool
.v2
.section_ids
;
9849 /* Reverse map for error checking. */
9850 int ids_seen
[DW_SECT_MAX
+ 1];
9855 error (_("Dwarf Error: bad DWP hash table, too few columns"
9856 " in section table [in module %s]"),
9859 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
9861 error (_("Dwarf Error: bad DWP hash table, too many columns"
9862 " in section table [in module %s]"),
9865 memset (ids
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9866 memset (ids_seen
, 255, (DW_SECT_MAX
+ 1) * sizeof (int32_t));
9867 for (i
= 0; i
< nr_columns
; ++i
)
9869 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
9871 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
9873 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9874 " in section table [in module %s]"),
9875 id
, dwp_file
->name
);
9877 if (ids_seen
[id
] != -1)
9879 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9880 " id %d in section table [in module %s]"),
9881 id
, dwp_file
->name
);
9886 /* Must have exactly one info or types section. */
9887 if (((ids_seen
[DW_SECT_INFO
] != -1)
9888 + (ids_seen
[DW_SECT_TYPES
] != -1))
9891 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9892 " DWO info/types section [in module %s]"),
9895 /* Must have an abbrev section. */
9896 if (ids_seen
[DW_SECT_ABBREV
] == -1)
9898 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9899 " section [in module %s]"),
9902 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
9903 htab
->section_pool
.v2
.sizes
=
9904 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
9905 * nr_units
* nr_columns
);
9906 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
9907 * nr_units
* nr_columns
))
9910 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9919 /* Update SECTIONS with the data from SECTP.
9921 This function is like the other "locate" section routines that are
9922 passed to bfd_map_over_sections, but in this context the sections to
9923 read comes from the DWP V1 hash table, not the full ELF section table.
9925 The result is non-zero for success, or zero if an error was found. */
9928 locate_v1_virtual_dwo_sections (asection
*sectp
,
9929 struct virtual_v1_dwo_sections
*sections
)
9931 const struct dwop_section_names
*names
= &dwop_section_names
;
9933 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
9935 /* There can be only one. */
9936 if (sections
->abbrev
.s
.asection
!= NULL
)
9938 sections
->abbrev
.s
.asection
= sectp
;
9939 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
9941 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
9942 || section_is_p (sectp
->name
, &names
->types_dwo
))
9944 /* There can be only one. */
9945 if (sections
->info_or_types
.s
.asection
!= NULL
)
9947 sections
->info_or_types
.s
.asection
= sectp
;
9948 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
9950 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
9952 /* There can be only one. */
9953 if (sections
->line
.s
.asection
!= NULL
)
9955 sections
->line
.s
.asection
= sectp
;
9956 sections
->line
.size
= bfd_get_section_size (sectp
);
9958 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
9960 /* There can be only one. */
9961 if (sections
->loc
.s
.asection
!= NULL
)
9963 sections
->loc
.s
.asection
= sectp
;
9964 sections
->loc
.size
= bfd_get_section_size (sectp
);
9966 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
9968 /* There can be only one. */
9969 if (sections
->macinfo
.s
.asection
!= NULL
)
9971 sections
->macinfo
.s
.asection
= sectp
;
9972 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
9974 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
9976 /* There can be only one. */
9977 if (sections
->macro
.s
.asection
!= NULL
)
9979 sections
->macro
.s
.asection
= sectp
;
9980 sections
->macro
.size
= bfd_get_section_size (sectp
);
9982 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
9984 /* There can be only one. */
9985 if (sections
->str_offsets
.s
.asection
!= NULL
)
9987 sections
->str_offsets
.s
.asection
= sectp
;
9988 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
9992 /* No other kind of section is valid. */
9999 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10000 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10001 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10002 This is for DWP version 1 files. */
10004 static struct dwo_unit
*
10005 create_dwo_unit_in_dwp_v1 (struct dwp_file
*dwp_file
,
10006 uint32_t unit_index
,
10007 const char *comp_dir
,
10008 ULONGEST signature
, int is_debug_types
)
10010 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10011 const struct dwp_hash_table
*dwp_htab
=
10012 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10013 bfd
*dbfd
= dwp_file
->dbfd
;
10014 const char *kind
= is_debug_types
? "TU" : "CU";
10015 struct dwo_file
*dwo_file
;
10016 struct dwo_unit
*dwo_unit
;
10017 struct virtual_v1_dwo_sections sections
;
10018 void **dwo_file_slot
;
10019 char *virtual_dwo_name
;
10020 struct dwarf2_section_info
*cutu
;
10021 struct cleanup
*cleanups
;
10024 gdb_assert (dwp_file
->version
== 1);
10026 if (dwarf_read_debug
)
10028 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
10030 pulongest (unit_index
), hex_string (signature
),
10034 /* Fetch the sections of this DWO unit.
10035 Put a limit on the number of sections we look for so that bad data
10036 doesn't cause us to loop forever. */
10038 #define MAX_NR_V1_DWO_SECTIONS \
10039 (1 /* .debug_info or .debug_types */ \
10040 + 1 /* .debug_abbrev */ \
10041 + 1 /* .debug_line */ \
10042 + 1 /* .debug_loc */ \
10043 + 1 /* .debug_str_offsets */ \
10044 + 1 /* .debug_macro or .debug_macinfo */ \
10045 + 1 /* trailing zero */)
10047 memset (§ions
, 0, sizeof (sections
));
10048 cleanups
= make_cleanup (null_cleanup
, 0);
10050 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
10053 uint32_t section_nr
=
10054 read_4_bytes (dbfd
,
10055 dwp_htab
->section_pool
.v1
.indices
10056 + (unit_index
+ i
) * sizeof (uint32_t));
10058 if (section_nr
== 0)
10060 if (section_nr
>= dwp_file
->num_sections
)
10062 error (_("Dwarf Error: bad DWP hash table, section number too large"
10063 " [in module %s]"),
10067 sectp
= dwp_file
->elf_sections
[section_nr
];
10068 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
10070 error (_("Dwarf Error: bad DWP hash table, invalid section found"
10071 " [in module %s]"),
10077 || dwarf2_section_empty_p (§ions
.info_or_types
)
10078 || dwarf2_section_empty_p (§ions
.abbrev
))
10080 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
10081 " [in module %s]"),
10084 if (i
== MAX_NR_V1_DWO_SECTIONS
)
10086 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
10087 " [in module %s]"),
10091 /* It's easier for the rest of the code if we fake a struct dwo_file and
10092 have dwo_unit "live" in that. At least for now.
10094 The DWP file can be made up of a random collection of CUs and TUs.
10095 However, for each CU + set of TUs that came from the same original DWO
10096 file, we can combine them back into a virtual DWO file to save space
10097 (fewer struct dwo_file objects to allocate). Remember that for really
10098 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10101 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
10102 get_section_id (§ions
.abbrev
),
10103 get_section_id (§ions
.line
),
10104 get_section_id (§ions
.loc
),
10105 get_section_id (§ions
.str_offsets
));
10106 make_cleanup (xfree
, virtual_dwo_name
);
10107 /* Can we use an existing virtual DWO file? */
10108 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10109 /* Create one if necessary. */
10110 if (*dwo_file_slot
== NULL
)
10112 if (dwarf_read_debug
)
10114 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10117 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10118 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
10120 strlen (virtual_dwo_name
));
10121 dwo_file
->comp_dir
= comp_dir
;
10122 dwo_file
->sections
.abbrev
= sections
.abbrev
;
10123 dwo_file
->sections
.line
= sections
.line
;
10124 dwo_file
->sections
.loc
= sections
.loc
;
10125 dwo_file
->sections
.macinfo
= sections
.macinfo
;
10126 dwo_file
->sections
.macro
= sections
.macro
;
10127 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
10128 /* The "str" section is global to the entire DWP file. */
10129 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10130 /* The info or types section is assigned below to dwo_unit,
10131 there's no need to record it in dwo_file.
10132 Also, we can't simply record type sections in dwo_file because
10133 we record a pointer into the vector in dwo_unit. As we collect more
10134 types we'll grow the vector and eventually have to reallocate space
10135 for it, invalidating all copies of pointers into the previous
10137 *dwo_file_slot
= dwo_file
;
10141 if (dwarf_read_debug
)
10143 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10146 dwo_file
= *dwo_file_slot
;
10148 do_cleanups (cleanups
);
10150 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10151 dwo_unit
->dwo_file
= dwo_file
;
10152 dwo_unit
->signature
= signature
;
10153 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
10154 sizeof (struct dwarf2_section_info
));
10155 *dwo_unit
->section
= sections
.info_or_types
;
10156 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10161 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
10162 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
10163 piece within that section used by a TU/CU, return a virtual section
10164 of just that piece. */
10166 static struct dwarf2_section_info
10167 create_dwp_v2_section (struct dwarf2_section_info
*section
,
10168 bfd_size_type offset
, bfd_size_type size
)
10170 struct dwarf2_section_info result
;
10173 gdb_assert (section
!= NULL
);
10174 gdb_assert (!section
->is_virtual
);
10176 memset (&result
, 0, sizeof (result
));
10177 result
.s
.containing_section
= section
;
10178 result
.is_virtual
= 1;
10183 sectp
= get_section_bfd_section (section
);
10185 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
10186 bounds of the real section. This is a pretty-rare event, so just
10187 flag an error (easier) instead of a warning and trying to cope. */
10189 || offset
+ size
> bfd_get_section_size (sectp
))
10191 bfd
*abfd
= sectp
->owner
;
10193 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
10194 " in section %s [in module %s]"),
10195 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
10196 objfile_name (dwarf2_per_objfile
->objfile
));
10199 result
.virtual_offset
= offset
;
10200 result
.size
= size
;
10204 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10205 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10206 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10207 This is for DWP version 2 files. */
10209 static struct dwo_unit
*
10210 create_dwo_unit_in_dwp_v2 (struct dwp_file
*dwp_file
,
10211 uint32_t unit_index
,
10212 const char *comp_dir
,
10213 ULONGEST signature
, int is_debug_types
)
10215 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10216 const struct dwp_hash_table
*dwp_htab
=
10217 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10218 bfd
*dbfd
= dwp_file
->dbfd
;
10219 const char *kind
= is_debug_types
? "TU" : "CU";
10220 struct dwo_file
*dwo_file
;
10221 struct dwo_unit
*dwo_unit
;
10222 struct virtual_v2_dwo_sections sections
;
10223 void **dwo_file_slot
;
10224 char *virtual_dwo_name
;
10225 struct dwarf2_section_info
*cutu
;
10226 struct cleanup
*cleanups
;
10229 gdb_assert (dwp_file
->version
== 2);
10231 if (dwarf_read_debug
)
10233 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
10235 pulongest (unit_index
), hex_string (signature
),
10239 /* Fetch the section offsets of this DWO unit. */
10241 memset (§ions
, 0, sizeof (sections
));
10242 cleanups
= make_cleanup (null_cleanup
, 0);
10244 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
10246 uint32_t offset
= read_4_bytes (dbfd
,
10247 dwp_htab
->section_pool
.v2
.offsets
10248 + (((unit_index
- 1) * dwp_htab
->nr_columns
10250 * sizeof (uint32_t)));
10251 uint32_t size
= read_4_bytes (dbfd
,
10252 dwp_htab
->section_pool
.v2
.sizes
10253 + (((unit_index
- 1) * dwp_htab
->nr_columns
10255 * sizeof (uint32_t)));
10257 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
10260 case DW_SECT_TYPES
:
10261 sections
.info_or_types_offset
= offset
;
10262 sections
.info_or_types_size
= size
;
10264 case DW_SECT_ABBREV
:
10265 sections
.abbrev_offset
= offset
;
10266 sections
.abbrev_size
= size
;
10269 sections
.line_offset
= offset
;
10270 sections
.line_size
= size
;
10273 sections
.loc_offset
= offset
;
10274 sections
.loc_size
= size
;
10276 case DW_SECT_STR_OFFSETS
:
10277 sections
.str_offsets_offset
= offset
;
10278 sections
.str_offsets_size
= size
;
10280 case DW_SECT_MACINFO
:
10281 sections
.macinfo_offset
= offset
;
10282 sections
.macinfo_size
= size
;
10284 case DW_SECT_MACRO
:
10285 sections
.macro_offset
= offset
;
10286 sections
.macro_size
= size
;
10291 /* It's easier for the rest of the code if we fake a struct dwo_file and
10292 have dwo_unit "live" in that. At least for now.
10294 The DWP file can be made up of a random collection of CUs and TUs.
10295 However, for each CU + set of TUs that came from the same original DWO
10296 file, we can combine them back into a virtual DWO file to save space
10297 (fewer struct dwo_file objects to allocate). Remember that for really
10298 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10301 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10302 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
10303 (long) (sections
.line_size
? sections
.line_offset
: 0),
10304 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
10305 (long) (sections
.str_offsets_size
10306 ? sections
.str_offsets_offset
: 0));
10307 make_cleanup (xfree
, virtual_dwo_name
);
10308 /* Can we use an existing virtual DWO file? */
10309 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
10310 /* Create one if necessary. */
10311 if (*dwo_file_slot
== NULL
)
10313 if (dwarf_read_debug
)
10315 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
10318 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10319 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
10321 strlen (virtual_dwo_name
));
10322 dwo_file
->comp_dir
= comp_dir
;
10323 dwo_file
->sections
.abbrev
=
10324 create_dwp_v2_section (&dwp_file
->sections
.abbrev
,
10325 sections
.abbrev_offset
, sections
.abbrev_size
);
10326 dwo_file
->sections
.line
=
10327 create_dwp_v2_section (&dwp_file
->sections
.line
,
10328 sections
.line_offset
, sections
.line_size
);
10329 dwo_file
->sections
.loc
=
10330 create_dwp_v2_section (&dwp_file
->sections
.loc
,
10331 sections
.loc_offset
, sections
.loc_size
);
10332 dwo_file
->sections
.macinfo
=
10333 create_dwp_v2_section (&dwp_file
->sections
.macinfo
,
10334 sections
.macinfo_offset
, sections
.macinfo_size
);
10335 dwo_file
->sections
.macro
=
10336 create_dwp_v2_section (&dwp_file
->sections
.macro
,
10337 sections
.macro_offset
, sections
.macro_size
);
10338 dwo_file
->sections
.str_offsets
=
10339 create_dwp_v2_section (&dwp_file
->sections
.str_offsets
,
10340 sections
.str_offsets_offset
,
10341 sections
.str_offsets_size
);
10342 /* The "str" section is global to the entire DWP file. */
10343 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
10344 /* The info or types section is assigned below to dwo_unit,
10345 there's no need to record it in dwo_file.
10346 Also, we can't simply record type sections in dwo_file because
10347 we record a pointer into the vector in dwo_unit. As we collect more
10348 types we'll grow the vector and eventually have to reallocate space
10349 for it, invalidating all copies of pointers into the previous
10351 *dwo_file_slot
= dwo_file
;
10355 if (dwarf_read_debug
)
10357 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
10360 dwo_file
= *dwo_file_slot
;
10362 do_cleanups (cleanups
);
10364 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
10365 dwo_unit
->dwo_file
= dwo_file
;
10366 dwo_unit
->signature
= signature
;
10367 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
10368 sizeof (struct dwarf2_section_info
));
10369 *dwo_unit
->section
= create_dwp_v2_section (is_debug_types
10370 ? &dwp_file
->sections
.types
10371 : &dwp_file
->sections
.info
,
10372 sections
.info_or_types_offset
,
10373 sections
.info_or_types_size
);
10374 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10379 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10380 Returns NULL if the signature isn't found. */
10382 static struct dwo_unit
*
10383 lookup_dwo_unit_in_dwp (struct dwp_file
*dwp_file
, const char *comp_dir
,
10384 ULONGEST signature
, int is_debug_types
)
10386 const struct dwp_hash_table
*dwp_htab
=
10387 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10388 bfd
*dbfd
= dwp_file
->dbfd
;
10389 uint32_t mask
= dwp_htab
->nr_slots
- 1;
10390 uint32_t hash
= signature
& mask
;
10391 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
10394 struct dwo_unit find_dwo_cu
, *dwo_cu
;
10396 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
10397 find_dwo_cu
.signature
= signature
;
10398 slot
= htab_find_slot (is_debug_types
10399 ? dwp_file
->loaded_tus
10400 : dwp_file
->loaded_cus
,
10401 &find_dwo_cu
, INSERT
);
10406 /* Use a for loop so that we don't loop forever on bad debug info. */
10407 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
10409 ULONGEST signature_in_table
;
10411 signature_in_table
=
10412 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
10413 if (signature_in_table
== signature
)
10415 uint32_t unit_index
=
10416 read_4_bytes (dbfd
,
10417 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
10419 if (dwp_file
->version
== 1)
10421 *slot
= create_dwo_unit_in_dwp_v1 (dwp_file
, unit_index
,
10422 comp_dir
, signature
,
10427 *slot
= create_dwo_unit_in_dwp_v2 (dwp_file
, unit_index
,
10428 comp_dir
, signature
,
10433 if (signature_in_table
== 0)
10435 hash
= (hash
+ hash2
) & mask
;
10438 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10439 " [in module %s]"),
10443 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10444 Open the file specified by FILE_NAME and hand it off to BFD for
10445 preliminary analysis. Return a newly initialized bfd *, which
10446 includes a canonicalized copy of FILE_NAME.
10447 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10448 SEARCH_CWD is true if the current directory is to be searched.
10449 It will be searched before debug-file-directory.
10450 If successful, the file is added to the bfd include table of the
10451 objfile's bfd (see gdb_bfd_record_inclusion).
10452 If unable to find/open the file, return NULL.
10453 NOTE: This function is derived from symfile_bfd_open. */
10456 try_open_dwop_file (const char *file_name
, int is_dwp
, int search_cwd
)
10460 char *absolute_name
;
10461 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10462 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10463 to debug_file_directory. */
10465 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
10469 if (*debug_file_directory
!= '\0')
10470 search_path
= concat (".", dirname_separator_string
,
10471 debug_file_directory
, NULL
);
10473 search_path
= xstrdup (".");
10476 search_path
= xstrdup (debug_file_directory
);
10478 flags
= OPF_RETURN_REALPATH
;
10480 flags
|= OPF_SEARCH_IN_PATH
;
10481 desc
= openp (search_path
, flags
, file_name
,
10482 O_RDONLY
| O_BINARY
, &absolute_name
);
10483 xfree (search_path
);
10487 sym_bfd
= gdb_bfd_open (absolute_name
, gnutarget
, desc
);
10488 xfree (absolute_name
);
10489 if (sym_bfd
== NULL
)
10491 bfd_set_cacheable (sym_bfd
, 1);
10493 if (!bfd_check_format (sym_bfd
, bfd_object
))
10495 gdb_bfd_unref (sym_bfd
); /* This also closes desc. */
10499 /* Success. Record the bfd as having been included by the objfile's bfd.
10500 This is important because things like demangled_names_hash lives in the
10501 objfile's per_bfd space and may have references to things like symbol
10502 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10503 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
);
10508 /* Try to open DWO file FILE_NAME.
10509 COMP_DIR is the DW_AT_comp_dir attribute.
10510 The result is the bfd handle of the file.
10511 If there is a problem finding or opening the file, return NULL.
10512 Upon success, the canonicalized path of the file is stored in the bfd,
10513 same as symfile_bfd_open. */
10516 open_dwo_file (const char *file_name
, const char *comp_dir
)
10520 if (IS_ABSOLUTE_PATH (file_name
))
10521 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 0 /*search_cwd*/);
10523 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10525 if (comp_dir
!= NULL
)
10527 char *path_to_try
= concat (comp_dir
, SLASH_STRING
, file_name
, NULL
);
10529 /* NOTE: If comp_dir is a relative path, this will also try the
10530 search path, which seems useful. */
10531 abfd
= try_open_dwop_file (path_to_try
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10532 xfree (path_to_try
);
10537 /* That didn't work, try debug-file-directory, which, despite its name,
10538 is a list of paths. */
10540 if (*debug_file_directory
== '\0')
10543 return try_open_dwop_file (file_name
, 0 /*is_dwp*/, 1 /*search_cwd*/);
10546 /* This function is mapped across the sections and remembers the offset and
10547 size of each of the DWO debugging sections we are interested in. */
10550 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
10552 struct dwo_sections
*dwo_sections
= dwo_sections_ptr
;
10553 const struct dwop_section_names
*names
= &dwop_section_names
;
10555 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10557 dwo_sections
->abbrev
.s
.asection
= sectp
;
10558 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
10560 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10562 dwo_sections
->info
.s
.asection
= sectp
;
10563 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
10565 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10567 dwo_sections
->line
.s
.asection
= sectp
;
10568 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
10570 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10572 dwo_sections
->loc
.s
.asection
= sectp
;
10573 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
10575 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10577 dwo_sections
->macinfo
.s
.asection
= sectp
;
10578 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
10580 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10582 dwo_sections
->macro
.s
.asection
= sectp
;
10583 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
10585 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
10587 dwo_sections
->str
.s
.asection
= sectp
;
10588 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
10590 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10592 dwo_sections
->str_offsets
.s
.asection
= sectp
;
10593 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
10595 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10597 struct dwarf2_section_info type_section
;
10599 memset (&type_section
, 0, sizeof (type_section
));
10600 type_section
.s
.asection
= sectp
;
10601 type_section
.size
= bfd_get_section_size (sectp
);
10602 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
10607 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10608 by PER_CU. This is for the non-DWP case.
10609 The result is NULL if DWO_NAME can't be found. */
10611 static struct dwo_file
*
10612 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
10613 const char *dwo_name
, const char *comp_dir
)
10615 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10616 struct dwo_file
*dwo_file
;
10618 struct cleanup
*cleanups
;
10620 dbfd
= open_dwo_file (dwo_name
, comp_dir
);
10623 if (dwarf_read_debug
)
10624 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
10627 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
10628 dwo_file
->dwo_name
= dwo_name
;
10629 dwo_file
->comp_dir
= comp_dir
;
10630 dwo_file
->dbfd
= dbfd
;
10632 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
10634 bfd_map_over_sections (dbfd
, dwarf2_locate_dwo_sections
, &dwo_file
->sections
);
10636 dwo_file
->cu
= create_dwo_cu (dwo_file
);
10638 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
10639 dwo_file
->sections
.types
);
10641 discard_cleanups (cleanups
);
10643 if (dwarf_read_debug
)
10644 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
10649 /* This function is mapped across the sections and remembers the offset and
10650 size of each of the DWP debugging sections common to version 1 and 2 that
10651 we are interested in. */
10654 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
10655 void *dwp_file_ptr
)
10657 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10658 const struct dwop_section_names
*names
= &dwop_section_names
;
10659 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10661 /* Record the ELF section number for later lookup: this is what the
10662 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10663 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10664 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10666 /* Look for specific sections that we need. */
10667 if (section_is_p (sectp
->name
, &names
->str_dwo
))
10669 dwp_file
->sections
.str
.s
.asection
= sectp
;
10670 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
10672 else if (section_is_p (sectp
->name
, &names
->cu_index
))
10674 dwp_file
->sections
.cu_index
.s
.asection
= sectp
;
10675 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
10677 else if (section_is_p (sectp
->name
, &names
->tu_index
))
10679 dwp_file
->sections
.tu_index
.s
.asection
= sectp
;
10680 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
10684 /* This function is mapped across the sections and remembers the offset and
10685 size of each of the DWP version 2 debugging sections that we are interested
10686 in. This is split into a separate function because we don't know if we
10687 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10690 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
10692 struct dwp_file
*dwp_file
= dwp_file_ptr
;
10693 const struct dwop_section_names
*names
= &dwop_section_names
;
10694 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
10696 /* Record the ELF section number for later lookup: this is what the
10697 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10698 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
10699 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
10701 /* Look for specific sections that we need. */
10702 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
10704 dwp_file
->sections
.abbrev
.s
.asection
= sectp
;
10705 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
10707 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
10709 dwp_file
->sections
.info
.s
.asection
= sectp
;
10710 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
10712 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
10714 dwp_file
->sections
.line
.s
.asection
= sectp
;
10715 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
10717 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
10719 dwp_file
->sections
.loc
.s
.asection
= sectp
;
10720 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
10722 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
10724 dwp_file
->sections
.macinfo
.s
.asection
= sectp
;
10725 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
10727 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
10729 dwp_file
->sections
.macro
.s
.asection
= sectp
;
10730 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
10732 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
10734 dwp_file
->sections
.str_offsets
.s
.asection
= sectp
;
10735 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
10737 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
10739 dwp_file
->sections
.types
.s
.asection
= sectp
;
10740 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
10744 /* Hash function for dwp_file loaded CUs/TUs. */
10747 hash_dwp_loaded_cutus (const void *item
)
10749 const struct dwo_unit
*dwo_unit
= item
;
10751 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10752 return dwo_unit
->signature
;
10755 /* Equality function for dwp_file loaded CUs/TUs. */
10758 eq_dwp_loaded_cutus (const void *a
, const void *b
)
10760 const struct dwo_unit
*dua
= a
;
10761 const struct dwo_unit
*dub
= b
;
10763 return dua
->signature
== dub
->signature
;
10766 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10769 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
10771 return htab_create_alloc_ex (3,
10772 hash_dwp_loaded_cutus
,
10773 eq_dwp_loaded_cutus
,
10775 &objfile
->objfile_obstack
,
10776 hashtab_obstack_allocate
,
10777 dummy_obstack_deallocate
);
10780 /* Try to open DWP file FILE_NAME.
10781 The result is the bfd handle of the file.
10782 If there is a problem finding or opening the file, return NULL.
10783 Upon success, the canonicalized path of the file is stored in the bfd,
10784 same as symfile_bfd_open. */
10787 open_dwp_file (const char *file_name
)
10791 abfd
= try_open_dwop_file (file_name
, 1 /*is_dwp*/, 1 /*search_cwd*/);
10795 /* Work around upstream bug 15652.
10796 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10797 [Whether that's a "bug" is debatable, but it is getting in our way.]
10798 We have no real idea where the dwp file is, because gdb's realpath-ing
10799 of the executable's path may have discarded the needed info.
10800 [IWBN if the dwp file name was recorded in the executable, akin to
10801 .gnu_debuglink, but that doesn't exist yet.]
10802 Strip the directory from FILE_NAME and search again. */
10803 if (*debug_file_directory
!= '\0')
10805 /* Don't implicitly search the current directory here.
10806 If the user wants to search "." to handle this case,
10807 it must be added to debug-file-directory. */
10808 return try_open_dwop_file (lbasename (file_name
), 1 /*is_dwp*/,
10815 /* Initialize the use of the DWP file for the current objfile.
10816 By convention the name of the DWP file is ${objfile}.dwp.
10817 The result is NULL if it can't be found. */
10819 static struct dwp_file
*
10820 open_and_init_dwp_file (void)
10822 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10823 struct dwp_file
*dwp_file
;
10826 struct cleanup
*cleanups
;
10828 /* Try to find first .dwp for the binary file before any symbolic links
10830 dwp_name
= xstrprintf ("%s.dwp", objfile
->original_name
);
10831 cleanups
= make_cleanup (xfree
, dwp_name
);
10833 dbfd
= open_dwp_file (dwp_name
);
10835 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
10837 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10838 dwp_name
= xstrprintf ("%s.dwp", objfile_name (objfile
));
10839 make_cleanup (xfree
, dwp_name
);
10840 dbfd
= open_dwp_file (dwp_name
);
10845 if (dwarf_read_debug
)
10846 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
);
10847 do_cleanups (cleanups
);
10850 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
10851 dwp_file
->name
= bfd_get_filename (dbfd
);
10852 dwp_file
->dbfd
= dbfd
;
10853 do_cleanups (cleanups
);
10855 /* +1: section 0 is unused */
10856 dwp_file
->num_sections
= bfd_count_sections (dbfd
) + 1;
10857 dwp_file
->elf_sections
=
10858 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
10859 dwp_file
->num_sections
, asection
*);
10861 bfd_map_over_sections (dbfd
, dwarf2_locate_common_dwp_sections
, dwp_file
);
10863 dwp_file
->cus
= create_dwp_hash_table (dwp_file
, 0);
10865 dwp_file
->tus
= create_dwp_hash_table (dwp_file
, 1);
10867 /* The DWP file version is stored in the hash table. Oh well. */
10868 if (dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
10870 /* Technically speaking, we should try to limp along, but this is
10871 pretty bizarre. We use pulongest here because that's the established
10872 portability solution (e.g, we cannot use %u for uint32_t). */
10873 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10874 " TU version %s [in DWP file %s]"),
10875 pulongest (dwp_file
->cus
->version
),
10876 pulongest (dwp_file
->tus
->version
), dwp_name
);
10878 dwp_file
->version
= dwp_file
->cus
->version
;
10880 if (dwp_file
->version
== 2)
10881 bfd_map_over_sections (dbfd
, dwarf2_locate_v2_dwp_sections
, dwp_file
);
10883 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
10884 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
10886 if (dwarf_read_debug
)
10888 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
10889 fprintf_unfiltered (gdb_stdlog
,
10890 " %s CUs, %s TUs\n",
10891 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
10892 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
10898 /* Wrapper around open_and_init_dwp_file, only open it once. */
10900 static struct dwp_file
*
10901 get_dwp_file (void)
10903 if (! dwarf2_per_objfile
->dwp_checked
)
10905 dwarf2_per_objfile
->dwp_file
= open_and_init_dwp_file ();
10906 dwarf2_per_objfile
->dwp_checked
= 1;
10908 return dwarf2_per_objfile
->dwp_file
;
10911 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10912 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10913 or in the DWP file for the objfile, referenced by THIS_UNIT.
10914 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10915 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10917 This is called, for example, when wanting to read a variable with a
10918 complex location. Therefore we don't want to do file i/o for every call.
10919 Therefore we don't want to look for a DWO file on every call.
10920 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10921 then we check if we've already seen DWO_NAME, and only THEN do we check
10924 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10925 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10927 static struct dwo_unit
*
10928 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
10929 const char *dwo_name
, const char *comp_dir
,
10930 ULONGEST signature
, int is_debug_types
)
10932 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10933 const char *kind
= is_debug_types
? "TU" : "CU";
10934 void **dwo_file_slot
;
10935 struct dwo_file
*dwo_file
;
10936 struct dwp_file
*dwp_file
;
10938 /* First see if there's a DWP file.
10939 If we have a DWP file but didn't find the DWO inside it, don't
10940 look for the original DWO file. It makes gdb behave differently
10941 depending on whether one is debugging in the build tree. */
10943 dwp_file
= get_dwp_file ();
10944 if (dwp_file
!= NULL
)
10946 const struct dwp_hash_table
*dwp_htab
=
10947 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
10949 if (dwp_htab
!= NULL
)
10951 struct dwo_unit
*dwo_cutu
=
10952 lookup_dwo_unit_in_dwp (dwp_file
, comp_dir
,
10953 signature
, is_debug_types
);
10955 if (dwo_cutu
!= NULL
)
10957 if (dwarf_read_debug
)
10959 fprintf_unfiltered (gdb_stdlog
,
10960 "Virtual DWO %s %s found: @%s\n",
10961 kind
, hex_string (signature
),
10962 host_address_to_string (dwo_cutu
));
10970 /* No DWP file, look for the DWO file. */
10972 dwo_file_slot
= lookup_dwo_file_slot (dwo_name
, comp_dir
);
10973 if (*dwo_file_slot
== NULL
)
10975 /* Read in the file and build a table of the CUs/TUs it contains. */
10976 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
10978 /* NOTE: This will be NULL if unable to open the file. */
10979 dwo_file
= *dwo_file_slot
;
10981 if (dwo_file
!= NULL
)
10983 struct dwo_unit
*dwo_cutu
= NULL
;
10985 if (is_debug_types
&& dwo_file
->tus
)
10987 struct dwo_unit find_dwo_cutu
;
10989 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
10990 find_dwo_cutu
.signature
= signature
;
10991 dwo_cutu
= htab_find (dwo_file
->tus
, &find_dwo_cutu
);
10993 else if (!is_debug_types
&& dwo_file
->cu
)
10995 if (signature
== dwo_file
->cu
->signature
)
10996 dwo_cutu
= dwo_file
->cu
;
10999 if (dwo_cutu
!= NULL
)
11001 if (dwarf_read_debug
)
11003 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
11004 kind
, dwo_name
, hex_string (signature
),
11005 host_address_to_string (dwo_cutu
));
11012 /* We didn't find it. This could mean a dwo_id mismatch, or
11013 someone deleted the DWO/DWP file, or the search path isn't set up
11014 correctly to find the file. */
11016 if (dwarf_read_debug
)
11018 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
11019 kind
, dwo_name
, hex_string (signature
));
11022 /* This is a warning and not a complaint because it can be caused by
11023 pilot error (e.g., user accidentally deleting the DWO). */
11025 /* Print the name of the DWP file if we looked there, helps the user
11026 better diagnose the problem. */
11027 char *dwp_text
= NULL
;
11028 struct cleanup
*cleanups
;
11030 if (dwp_file
!= NULL
)
11031 dwp_text
= xstrprintf (" [in DWP file %s]", lbasename (dwp_file
->name
));
11032 cleanups
= make_cleanup (xfree
, dwp_text
);
11034 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
11035 " [in module %s]"),
11036 kind
, dwo_name
, hex_string (signature
),
11037 dwp_text
!= NULL
? dwp_text
: "",
11038 this_unit
->is_debug_types
? "TU" : "CU",
11039 this_unit
->offset
.sect_off
, objfile_name (objfile
));
11041 do_cleanups (cleanups
);
11046 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
11047 See lookup_dwo_cutu_unit for details. */
11049 static struct dwo_unit
*
11050 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
11051 const char *dwo_name
, const char *comp_dir
,
11052 ULONGEST signature
)
11054 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
11057 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
11058 See lookup_dwo_cutu_unit for details. */
11060 static struct dwo_unit
*
11061 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
11062 const char *dwo_name
, const char *comp_dir
)
11064 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
11067 /* Traversal function for queue_and_load_all_dwo_tus. */
11070 queue_and_load_dwo_tu (void **slot
, void *info
)
11072 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
11073 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
11074 ULONGEST signature
= dwo_unit
->signature
;
11075 struct signatured_type
*sig_type
=
11076 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
11078 if (sig_type
!= NULL
)
11080 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
11082 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
11083 a real dependency of PER_CU on SIG_TYPE. That is detected later
11084 while processing PER_CU. */
11085 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
11086 load_full_type_unit (sig_cu
);
11087 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
11093 /* Queue all TUs contained in the DWO of PER_CU to be read in.
11094 The DWO may have the only definition of the type, though it may not be
11095 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
11096 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
11099 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
11101 struct dwo_unit
*dwo_unit
;
11102 struct dwo_file
*dwo_file
;
11104 gdb_assert (!per_cu
->is_debug_types
);
11105 gdb_assert (get_dwp_file () == NULL
);
11106 gdb_assert (per_cu
->cu
!= NULL
);
11108 dwo_unit
= per_cu
->cu
->dwo_unit
;
11109 gdb_assert (dwo_unit
!= NULL
);
11111 dwo_file
= dwo_unit
->dwo_file
;
11112 if (dwo_file
->tus
!= NULL
)
11113 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
11116 /* Free all resources associated with DWO_FILE.
11117 Close the DWO file and munmap the sections.
11118 All memory should be on the objfile obstack. */
11121 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
11124 struct dwarf2_section_info
*section
;
11126 /* Note: dbfd is NULL for virtual DWO files. */
11127 gdb_bfd_unref (dwo_file
->dbfd
);
11129 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
11132 /* Wrapper for free_dwo_file for use in cleanups. */
11135 free_dwo_file_cleanup (void *arg
)
11137 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
11138 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11140 free_dwo_file (dwo_file
, objfile
);
11143 /* Traversal function for free_dwo_files. */
11146 free_dwo_file_from_slot (void **slot
, void *info
)
11148 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
11149 struct objfile
*objfile
= (struct objfile
*) info
;
11151 free_dwo_file (dwo_file
, objfile
);
11156 /* Free all resources associated with DWO_FILES. */
11159 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
11161 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
11164 /* Read in various DIEs. */
11166 /* qsort helper for inherit_abstract_dies. */
11169 unsigned_int_compar (const void *ap
, const void *bp
)
11171 unsigned int a
= *(unsigned int *) ap
;
11172 unsigned int b
= *(unsigned int *) bp
;
11174 return (a
> b
) - (b
> a
);
11177 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
11178 Inherit only the children of the DW_AT_abstract_origin DIE not being
11179 already referenced by DW_AT_abstract_origin from the children of the
11183 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
11185 struct die_info
*child_die
;
11186 unsigned die_children_count
;
11187 /* CU offsets which were referenced by children of the current DIE. */
11188 sect_offset
*offsets
;
11189 sect_offset
*offsets_end
, *offsetp
;
11190 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
11191 struct die_info
*origin_die
;
11192 /* Iterator of the ORIGIN_DIE children. */
11193 struct die_info
*origin_child_die
;
11194 struct cleanup
*cleanups
;
11195 struct attribute
*attr
;
11196 struct dwarf2_cu
*origin_cu
;
11197 struct pending
**origin_previous_list_in_scope
;
11199 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11203 /* Note that following die references may follow to a die in a
11207 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
11209 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
11211 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
11212 origin_cu
->list_in_scope
= cu
->list_in_scope
;
11214 if (die
->tag
!= origin_die
->tag
11215 && !(die
->tag
== DW_TAG_inlined_subroutine
11216 && origin_die
->tag
== DW_TAG_subprogram
))
11217 complaint (&symfile_complaints
,
11218 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
11219 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
11221 child_die
= die
->child
;
11222 die_children_count
= 0;
11223 while (child_die
&& child_die
->tag
)
11225 child_die
= sibling_die (child_die
);
11226 die_children_count
++;
11228 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
11229 cleanups
= make_cleanup (xfree
, offsets
);
11231 offsets_end
= offsets
;
11232 for (child_die
= die
->child
;
11233 child_die
&& child_die
->tag
;
11234 child_die
= sibling_die (child_die
))
11236 struct die_info
*child_origin_die
;
11237 struct dwarf2_cu
*child_origin_cu
;
11239 /* We are trying to process concrete instance entries:
11240 DW_TAG_GNU_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
11241 it's not relevant to our analysis here. i.e. detecting DIEs that are
11242 present in the abstract instance but not referenced in the concrete
11244 if (child_die
->tag
== DW_TAG_GNU_call_site
)
11247 /* For each CHILD_DIE, find the corresponding child of
11248 ORIGIN_DIE. If there is more than one layer of
11249 DW_AT_abstract_origin, follow them all; there shouldn't be,
11250 but GCC versions at least through 4.4 generate this (GCC PR
11252 child_origin_die
= child_die
;
11253 child_origin_cu
= cu
;
11256 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
11260 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
11264 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
11265 counterpart may exist. */
11266 if (child_origin_die
!= child_die
)
11268 if (child_die
->tag
!= child_origin_die
->tag
11269 && !(child_die
->tag
== DW_TAG_inlined_subroutine
11270 && child_origin_die
->tag
== DW_TAG_subprogram
))
11271 complaint (&symfile_complaints
,
11272 _("Child DIE 0x%x and its abstract origin 0x%x have "
11273 "different tags"), child_die
->offset
.sect_off
,
11274 child_origin_die
->offset
.sect_off
);
11275 if (child_origin_die
->parent
!= origin_die
)
11276 complaint (&symfile_complaints
,
11277 _("Child DIE 0x%x and its abstract origin 0x%x have "
11278 "different parents"), child_die
->offset
.sect_off
,
11279 child_origin_die
->offset
.sect_off
);
11281 *offsets_end
++ = child_origin_die
->offset
;
11284 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
11285 unsigned_int_compar
);
11286 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
11287 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
11288 complaint (&symfile_complaints
,
11289 _("Multiple children of DIE 0x%x refer "
11290 "to DIE 0x%x as their abstract origin"),
11291 die
->offset
.sect_off
, offsetp
->sect_off
);
11294 origin_child_die
= origin_die
->child
;
11295 while (origin_child_die
&& origin_child_die
->tag
)
11297 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11298 while (offsetp
< offsets_end
11299 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
11301 if (offsetp
>= offsets_end
11302 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
11304 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11305 Check whether we're already processing ORIGIN_CHILD_DIE.
11306 This can happen with mutually referenced abstract_origins.
11308 if (!origin_child_die
->in_process
)
11309 process_die (origin_child_die
, origin_cu
);
11311 origin_child_die
= sibling_die (origin_child_die
);
11313 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
11315 do_cleanups (cleanups
);
11319 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11321 struct objfile
*objfile
= cu
->objfile
;
11322 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11323 struct context_stack
*newobj
;
11326 struct die_info
*child_die
;
11327 struct attribute
*attr
, *call_line
, *call_file
;
11329 CORE_ADDR baseaddr
;
11330 struct block
*block
;
11331 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11332 VEC (symbolp
) *template_args
= NULL
;
11333 struct template_symbol
*templ_func
= NULL
;
11337 /* If we do not have call site information, we can't show the
11338 caller of this inlined function. That's too confusing, so
11339 only use the scope for local variables. */
11340 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
11341 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
11342 if (call_line
== NULL
|| call_file
== NULL
)
11344 read_lexical_block_scope (die
, cu
);
11349 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11351 name
= dwarf2_name (die
, cu
);
11353 /* Ignore functions with missing or empty names. These are actually
11354 illegal according to the DWARF standard. */
11357 complaint (&symfile_complaints
,
11358 _("missing name for subprogram DIE at %d"),
11359 die
->offset
.sect_off
);
11363 /* Ignore functions with missing or invalid low and high pc attributes. */
11364 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11366 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
11367 if (!attr
|| !DW_UNSND (attr
))
11368 complaint (&symfile_complaints
,
11369 _("cannot get low and high bounds "
11370 "for subprogram DIE at %d"),
11371 die
->offset
.sect_off
);
11375 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11376 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11378 /* If we have any template arguments, then we must allocate a
11379 different sort of symbol. */
11380 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
11382 if (child_die
->tag
== DW_TAG_template_type_param
11383 || child_die
->tag
== DW_TAG_template_value_param
)
11385 templ_func
= allocate_template_symbol (objfile
);
11386 templ_func
->base
.is_cplus_template_function
= 1;
11391 newobj
= push_context (0, lowpc
);
11392 newobj
->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
11393 (struct symbol
*) templ_func
);
11395 /* If there is a location expression for DW_AT_frame_base, record
11397 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
11399 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
11401 cu
->list_in_scope
= &local_symbols
;
11403 if (die
->child
!= NULL
)
11405 child_die
= die
->child
;
11406 while (child_die
&& child_die
->tag
)
11408 if (child_die
->tag
== DW_TAG_template_type_param
11409 || child_die
->tag
== DW_TAG_template_value_param
)
11411 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
11414 VEC_safe_push (symbolp
, template_args
, arg
);
11417 process_die (child_die
, cu
);
11418 child_die
= sibling_die (child_die
);
11422 inherit_abstract_dies (die
, cu
);
11424 /* If we have a DW_AT_specification, we might need to import using
11425 directives from the context of the specification DIE. See the
11426 comment in determine_prefix. */
11427 if (cu
->language
== language_cplus
11428 && dwarf2_attr (die
, DW_AT_specification
, cu
))
11430 struct dwarf2_cu
*spec_cu
= cu
;
11431 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
11435 child_die
= spec_die
->child
;
11436 while (child_die
&& child_die
->tag
)
11438 if (child_die
->tag
== DW_TAG_imported_module
)
11439 process_die (child_die
, spec_cu
);
11440 child_die
= sibling_die (child_die
);
11443 /* In some cases, GCC generates specification DIEs that
11444 themselves contain DW_AT_specification attributes. */
11445 spec_die
= die_specification (spec_die
, &spec_cu
);
11449 newobj
= pop_context ();
11450 /* Make a block for the local symbols within. */
11451 block
= finish_block (newobj
->name
, &local_symbols
, newobj
->old_blocks
,
11454 /* For C++, set the block's scope. */
11455 if ((cu
->language
== language_cplus
11456 || cu
->language
== language_fortran
11457 || cu
->language
== language_d
)
11458 && cu
->processing_has_namespace_info
)
11459 block_set_scope (block
, determine_prefix (die
, cu
),
11460 &objfile
->objfile_obstack
);
11462 /* If we have address ranges, record them. */
11463 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11465 gdbarch_make_symbol_special (gdbarch
, newobj
->name
, objfile
);
11467 /* Attach template arguments to function. */
11468 if (! VEC_empty (symbolp
, template_args
))
11470 gdb_assert (templ_func
!= NULL
);
11472 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
11473 templ_func
->template_arguments
11474 = obstack_alloc (&objfile
->objfile_obstack
,
11475 (templ_func
->n_template_arguments
11476 * sizeof (struct symbol
*)));
11477 memcpy (templ_func
->template_arguments
,
11478 VEC_address (symbolp
, template_args
),
11479 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
11480 VEC_free (symbolp
, template_args
);
11483 /* In C++, we can have functions nested inside functions (e.g., when
11484 a function declares a class that has methods). This means that
11485 when we finish processing a function scope, we may need to go
11486 back to building a containing block's symbol lists. */
11487 local_symbols
= newobj
->locals
;
11488 using_directives
= newobj
->using_directives
;
11490 /* If we've finished processing a top-level function, subsequent
11491 symbols go in the file symbol list. */
11492 if (outermost_context_p ())
11493 cu
->list_in_scope
= &file_symbols
;
11496 /* Process all the DIES contained within a lexical block scope. Start
11497 a new scope, process the dies, and then close the scope. */
11500 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11502 struct objfile
*objfile
= cu
->objfile
;
11503 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11504 struct context_stack
*newobj
;
11505 CORE_ADDR lowpc
, highpc
;
11506 struct die_info
*child_die
;
11507 CORE_ADDR baseaddr
;
11509 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11511 /* Ignore blocks with missing or invalid low and high pc attributes. */
11512 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11513 as multiple lexical blocks? Handling children in a sane way would
11514 be nasty. Might be easier to properly extend generic blocks to
11515 describe ranges. */
11516 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
11518 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11519 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
11521 push_context (0, lowpc
);
11522 if (die
->child
!= NULL
)
11524 child_die
= die
->child
;
11525 while (child_die
&& child_die
->tag
)
11527 process_die (child_die
, cu
);
11528 child_die
= sibling_die (child_die
);
11531 inherit_abstract_dies (die
, cu
);
11532 newobj
= pop_context ();
11534 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
11536 struct block
*block
11537 = finish_block (0, &local_symbols
, newobj
->old_blocks
,
11538 newobj
->start_addr
, highpc
);
11540 /* Note that recording ranges after traversing children, as we
11541 do here, means that recording a parent's ranges entails
11542 walking across all its children's ranges as they appear in
11543 the address map, which is quadratic behavior.
11545 It would be nicer to record the parent's ranges before
11546 traversing its children, simply overriding whatever you find
11547 there. But since we don't even decide whether to create a
11548 block until after we've traversed its children, that's hard
11550 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
11552 local_symbols
= newobj
->locals
;
11553 using_directives
= newobj
->using_directives
;
11556 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11559 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11561 struct objfile
*objfile
= cu
->objfile
;
11562 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11563 CORE_ADDR pc
, baseaddr
;
11564 struct attribute
*attr
;
11565 struct call_site
*call_site
, call_site_local
;
11568 struct die_info
*child_die
;
11570 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11572 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11575 complaint (&symfile_complaints
,
11576 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11577 "DIE 0x%x [in module %s]"),
11578 die
->offset
.sect_off
, objfile_name (objfile
));
11581 pc
= attr_value_as_address (attr
) + baseaddr
;
11582 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
11584 if (cu
->call_site_htab
== NULL
)
11585 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
11586 NULL
, &objfile
->objfile_obstack
,
11587 hashtab_obstack_allocate
, NULL
);
11588 call_site_local
.pc
= pc
;
11589 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
11592 complaint (&symfile_complaints
,
11593 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11594 "DIE 0x%x [in module %s]"),
11595 paddress (gdbarch
, pc
), die
->offset
.sect_off
,
11596 objfile_name (objfile
));
11600 /* Count parameters at the caller. */
11603 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11604 child_die
= sibling_die (child_die
))
11606 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11608 complaint (&symfile_complaints
,
11609 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11610 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11611 child_die
->tag
, child_die
->offset
.sect_off
,
11612 objfile_name (objfile
));
11619 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
11620 (sizeof (*call_site
)
11621 + (sizeof (*call_site
->parameter
)
11622 * (nparams
- 1))));
11624 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
11625 call_site
->pc
= pc
;
11627 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
11629 struct die_info
*func_die
;
11631 /* Skip also over DW_TAG_inlined_subroutine. */
11632 for (func_die
= die
->parent
;
11633 func_die
&& func_die
->tag
!= DW_TAG_subprogram
11634 && func_die
->tag
!= DW_TAG_subroutine_type
;
11635 func_die
= func_die
->parent
);
11637 /* DW_AT_GNU_all_call_sites is a superset
11638 of DW_AT_GNU_all_tail_call_sites. */
11640 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
11641 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
11643 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11644 not complete. But keep CALL_SITE for look ups via call_site_htab,
11645 both the initial caller containing the real return address PC and
11646 the final callee containing the current PC of a chain of tail
11647 calls do not need to have the tail call list complete. But any
11648 function candidate for a virtual tail call frame searched via
11649 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11650 determined unambiguously. */
11654 struct type
*func_type
= NULL
;
11657 func_type
= get_die_type (func_die
, cu
);
11658 if (func_type
!= NULL
)
11660 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
11662 /* Enlist this call site to the function. */
11663 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
11664 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
11667 complaint (&symfile_complaints
,
11668 _("Cannot find function owning DW_TAG_GNU_call_site "
11669 "DIE 0x%x [in module %s]"),
11670 die
->offset
.sect_off
, objfile_name (objfile
));
11674 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
11676 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
11677 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
11678 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
11679 /* Keep NULL DWARF_BLOCK. */;
11680 else if (attr_form_is_block (attr
))
11682 struct dwarf2_locexpr_baton
*dlbaton
;
11684 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
11685 dlbaton
->data
= DW_BLOCK (attr
)->data
;
11686 dlbaton
->size
= DW_BLOCK (attr
)->size
;
11687 dlbaton
->per_cu
= cu
->per_cu
;
11689 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
11691 else if (attr_form_is_ref (attr
))
11693 struct dwarf2_cu
*target_cu
= cu
;
11694 struct die_info
*target_die
;
11696 target_die
= follow_die_ref (die
, attr
, &target_cu
);
11697 gdb_assert (target_cu
->objfile
== objfile
);
11698 if (die_is_declaration (target_die
, target_cu
))
11700 const char *target_physname
= NULL
;
11701 struct attribute
*target_attr
;
11703 /* Prefer the mangled name; otherwise compute the demangled one. */
11704 target_attr
= dwarf2_attr (target_die
, DW_AT_linkage_name
, target_cu
);
11705 if (target_attr
== NULL
)
11706 target_attr
= dwarf2_attr (target_die
, DW_AT_MIPS_linkage_name
,
11708 if (target_attr
!= NULL
&& DW_STRING (target_attr
) != NULL
)
11709 target_physname
= DW_STRING (target_attr
);
11711 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
11712 if (target_physname
== NULL
)
11713 complaint (&symfile_complaints
,
11714 _("DW_AT_GNU_call_site_target target DIE has invalid "
11715 "physname, for referencing DIE 0x%x [in module %s]"),
11716 die
->offset
.sect_off
, objfile_name (objfile
));
11718 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
11724 /* DW_AT_entry_pc should be preferred. */
11725 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
11726 complaint (&symfile_complaints
,
11727 _("DW_AT_GNU_call_site_target target DIE has invalid "
11728 "low pc, for referencing DIE 0x%x [in module %s]"),
11729 die
->offset
.sect_off
, objfile_name (objfile
));
11732 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11733 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
11738 complaint (&symfile_complaints
,
11739 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11740 "block nor reference, for DIE 0x%x [in module %s]"),
11741 die
->offset
.sect_off
, objfile_name (objfile
));
11743 call_site
->per_cu
= cu
->per_cu
;
11745 for (child_die
= die
->child
;
11746 child_die
&& child_die
->tag
;
11747 child_die
= sibling_die (child_die
))
11749 struct call_site_parameter
*parameter
;
11750 struct attribute
*loc
, *origin
;
11752 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
11754 /* Already printed the complaint above. */
11758 gdb_assert (call_site
->parameter_count
< nparams
);
11759 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
11761 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11762 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11763 register is contained in DW_AT_GNU_call_site_value. */
11765 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
11766 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
11767 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
11769 sect_offset offset
;
11771 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
11772 offset
= dwarf2_get_ref_die_offset (origin
);
11773 if (!offset_in_cu_p (&cu
->header
, offset
))
11775 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11776 binding can be done only inside one CU. Such referenced DIE
11777 therefore cannot be even moved to DW_TAG_partial_unit. */
11778 complaint (&symfile_complaints
,
11779 _("DW_AT_abstract_origin offset is not in CU for "
11780 "DW_TAG_GNU_call_site child DIE 0x%x "
11782 child_die
->offset
.sect_off
, objfile_name (objfile
));
11785 parameter
->u
.param_offset
.cu_off
= (offset
.sect_off
11786 - cu
->header
.offset
.sect_off
);
11788 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
11790 complaint (&symfile_complaints
,
11791 _("No DW_FORM_block* DW_AT_location for "
11792 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11793 child_die
->offset
.sect_off
, objfile_name (objfile
));
11798 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
11799 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
11800 if (parameter
->u
.dwarf_reg
!= -1)
11801 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
11802 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
11803 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
11804 ¶meter
->u
.fb_offset
))
11805 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
11808 complaint (&symfile_complaints
,
11809 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11810 "for DW_FORM_block* DW_AT_location is supported for "
11811 "DW_TAG_GNU_call_site child DIE 0x%x "
11813 child_die
->offset
.sect_off
, objfile_name (objfile
));
11818 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
11819 if (!attr_form_is_block (attr
))
11821 complaint (&symfile_complaints
,
11822 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11823 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11824 child_die
->offset
.sect_off
, objfile_name (objfile
));
11827 parameter
->value
= DW_BLOCK (attr
)->data
;
11828 parameter
->value_size
= DW_BLOCK (attr
)->size
;
11830 /* Parameters are not pre-cleared by memset above. */
11831 parameter
->data_value
= NULL
;
11832 parameter
->data_value_size
= 0;
11833 call_site
->parameter_count
++;
11835 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
11838 if (!attr_form_is_block (attr
))
11839 complaint (&symfile_complaints
,
11840 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11841 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11842 child_die
->offset
.sect_off
, objfile_name (objfile
));
11845 parameter
->data_value
= DW_BLOCK (attr
)->data
;
11846 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
11852 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11853 Return 1 if the attributes are present and valid, otherwise, return 0.
11854 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11857 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
11858 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
11859 struct partial_symtab
*ranges_pst
)
11861 struct objfile
*objfile
= cu
->objfile
;
11862 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11863 struct comp_unit_head
*cu_header
= &cu
->header
;
11864 bfd
*obfd
= objfile
->obfd
;
11865 unsigned int addr_size
= cu_header
->addr_size
;
11866 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
11867 /* Base address selection entry. */
11870 unsigned int dummy
;
11871 const gdb_byte
*buffer
;
11875 CORE_ADDR high
= 0;
11876 CORE_ADDR baseaddr
;
11878 found_base
= cu
->base_known
;
11879 base
= cu
->base_address
;
11881 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
11882 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
11884 complaint (&symfile_complaints
,
11885 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11889 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
11891 /* Read in the largest possible address. */
11892 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
11893 if ((marker
& mask
) == mask
)
11895 /* If we found the largest possible address, then
11896 read the base address. */
11897 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11898 buffer
+= 2 * addr_size
;
11899 offset
+= 2 * addr_size
;
11905 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11909 CORE_ADDR range_beginning
, range_end
;
11911 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
11912 buffer
+= addr_size
;
11913 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
11914 buffer
+= addr_size
;
11915 offset
+= 2 * addr_size
;
11917 /* An end of list marker is a pair of zero addresses. */
11918 if (range_beginning
== 0 && range_end
== 0)
11919 /* Found the end of list entry. */
11922 /* Each base address selection entry is a pair of 2 values.
11923 The first is the largest possible address, the second is
11924 the base address. Check for a base address here. */
11925 if ((range_beginning
& mask
) == mask
)
11927 /* If we found the largest possible address, then
11928 read the base address. */
11929 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
11936 /* We have no valid base address for the ranges
11938 complaint (&symfile_complaints
,
11939 _("Invalid .debug_ranges data (no base address)"));
11943 if (range_beginning
> range_end
)
11945 /* Inverted range entries are invalid. */
11946 complaint (&symfile_complaints
,
11947 _("Invalid .debug_ranges data (inverted range)"));
11951 /* Empty range entries have no effect. */
11952 if (range_beginning
== range_end
)
11955 range_beginning
+= base
;
11958 /* A not-uncommon case of bad debug info.
11959 Don't pollute the addrmap with bad data. */
11960 if (range_beginning
+ baseaddr
== 0
11961 && !dwarf2_per_objfile
->has_section_at_zero
)
11963 complaint (&symfile_complaints
,
11964 _(".debug_ranges entry has start address of zero"
11965 " [in module %s]"), objfile_name (objfile
));
11969 if (ranges_pst
!= NULL
)
11974 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
11975 range_beginning
+ baseaddr
);
11976 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
,
11977 range_end
+ baseaddr
);
11978 addrmap_set_empty (objfile
->psymtabs_addrmap
, lowpc
, highpc
- 1,
11982 /* FIXME: This is recording everything as a low-high
11983 segment of consecutive addresses. We should have a
11984 data structure for discontiguous block ranges
11988 low
= range_beginning
;
11994 if (range_beginning
< low
)
11995 low
= range_beginning
;
11996 if (range_end
> high
)
12002 /* If the first entry is an end-of-list marker, the range
12003 describes an empty scope, i.e. no instructions. */
12009 *high_return
= high
;
12013 /* Get low and high pc attributes from a die. Return 1 if the attributes
12014 are present and valid, otherwise, return 0. Return -1 if the range is
12015 discontinuous, i.e. derived from DW_AT_ranges information. */
12018 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
12019 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
12020 struct partial_symtab
*pst
)
12022 struct attribute
*attr
;
12023 struct attribute
*attr_high
;
12025 CORE_ADDR high
= 0;
12028 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12031 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12034 low
= attr_value_as_address (attr
);
12035 high
= attr_value_as_address (attr_high
);
12036 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12040 /* Found high w/o low attribute. */
12043 /* Found consecutive range of addresses. */
12048 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12051 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12052 We take advantage of the fact that DW_AT_ranges does not appear
12053 in DW_TAG_compile_unit of DWO files. */
12054 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12055 unsigned int ranges_offset
= (DW_UNSND (attr
)
12056 + (need_ranges_base
12060 /* Value of the DW_AT_ranges attribute is the offset in the
12061 .debug_ranges section. */
12062 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
12064 /* Found discontinuous range of addresses. */
12069 /* read_partial_die has also the strict LOW < HIGH requirement. */
12073 /* When using the GNU linker, .gnu.linkonce. sections are used to
12074 eliminate duplicate copies of functions and vtables and such.
12075 The linker will arbitrarily choose one and discard the others.
12076 The AT_*_pc values for such functions refer to local labels in
12077 these sections. If the section from that file was discarded, the
12078 labels are not in the output, so the relocs get a value of 0.
12079 If this is a discarded function, mark the pc bounds as invalid,
12080 so that GDB will ignore it. */
12081 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12090 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
12091 its low and high PC addresses. Do nothing if these addresses could not
12092 be determined. Otherwise, set LOWPC to the low address if it is smaller,
12093 and HIGHPC to the high address if greater than HIGHPC. */
12096 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
12097 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12098 struct dwarf2_cu
*cu
)
12100 CORE_ADDR low
, high
;
12101 struct die_info
*child
= die
->child
;
12103 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
12105 *lowpc
= min (*lowpc
, low
);
12106 *highpc
= max (*highpc
, high
);
12109 /* If the language does not allow nested subprograms (either inside
12110 subprograms or lexical blocks), we're done. */
12111 if (cu
->language
!= language_ada
)
12114 /* Check all the children of the given DIE. If it contains nested
12115 subprograms, then check their pc bounds. Likewise, we need to
12116 check lexical blocks as well, as they may also contain subprogram
12118 while (child
&& child
->tag
)
12120 if (child
->tag
== DW_TAG_subprogram
12121 || child
->tag
== DW_TAG_lexical_block
)
12122 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
12123 child
= sibling_die (child
);
12127 /* Get the low and high pc's represented by the scope DIE, and store
12128 them in *LOWPC and *HIGHPC. If the correct values can't be
12129 determined, set *LOWPC to -1 and *HIGHPC to 0. */
12132 get_scope_pc_bounds (struct die_info
*die
,
12133 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
12134 struct dwarf2_cu
*cu
)
12136 CORE_ADDR best_low
= (CORE_ADDR
) -1;
12137 CORE_ADDR best_high
= (CORE_ADDR
) 0;
12138 CORE_ADDR current_low
, current_high
;
12140 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
12142 best_low
= current_low
;
12143 best_high
= current_high
;
12147 struct die_info
*child
= die
->child
;
12149 while (child
&& child
->tag
)
12151 switch (child
->tag
) {
12152 case DW_TAG_subprogram
:
12153 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
12155 case DW_TAG_namespace
:
12156 case DW_TAG_module
:
12157 /* FIXME: carlton/2004-01-16: Should we do this for
12158 DW_TAG_class_type/DW_TAG_structure_type, too? I think
12159 that current GCC's always emit the DIEs corresponding
12160 to definitions of methods of classes as children of a
12161 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
12162 the DIEs giving the declarations, which could be
12163 anywhere). But I don't see any reason why the
12164 standards says that they have to be there. */
12165 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
12167 if (current_low
!= ((CORE_ADDR
) -1))
12169 best_low
= min (best_low
, current_low
);
12170 best_high
= max (best_high
, current_high
);
12178 child
= sibling_die (child
);
12183 *highpc
= best_high
;
12186 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
12190 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
12191 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
12193 struct objfile
*objfile
= cu
->objfile
;
12194 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12195 struct attribute
*attr
;
12196 struct attribute
*attr_high
;
12198 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
12201 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
12204 CORE_ADDR low
= attr_value_as_address (attr
);
12205 CORE_ADDR high
= attr_value_as_address (attr_high
);
12207 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
12210 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
12211 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
12212 record_block_range (block
, low
, high
- 1);
12216 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
12219 bfd
*obfd
= objfile
->obfd
;
12220 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12221 We take advantage of the fact that DW_AT_ranges does not appear
12222 in DW_TAG_compile_unit of DWO files. */
12223 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
12225 /* The value of the DW_AT_ranges attribute is the offset of the
12226 address range list in the .debug_ranges section. */
12227 unsigned long offset
= (DW_UNSND (attr
)
12228 + (need_ranges_base
? cu
->ranges_base
: 0));
12229 const gdb_byte
*buffer
;
12231 /* For some target architectures, but not others, the
12232 read_address function sign-extends the addresses it returns.
12233 To recognize base address selection entries, we need a
12235 unsigned int addr_size
= cu
->header
.addr_size
;
12236 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
12238 /* The base address, to which the next pair is relative. Note
12239 that this 'base' is a DWARF concept: most entries in a range
12240 list are relative, to reduce the number of relocs against the
12241 debugging information. This is separate from this function's
12242 'baseaddr' argument, which GDB uses to relocate debugging
12243 information from a shared library based on the address at
12244 which the library was loaded. */
12245 CORE_ADDR base
= cu
->base_address
;
12246 int base_known
= cu
->base_known
;
12248 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
12249 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
12251 complaint (&symfile_complaints
,
12252 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
12256 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
12260 unsigned int bytes_read
;
12261 CORE_ADDR start
, end
;
12263 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12264 buffer
+= bytes_read
;
12265 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
12266 buffer
+= bytes_read
;
12268 /* Did we find the end of the range list? */
12269 if (start
== 0 && end
== 0)
12272 /* Did we find a base address selection entry? */
12273 else if ((start
& base_select_mask
) == base_select_mask
)
12279 /* We found an ordinary address range. */
12284 complaint (&symfile_complaints
,
12285 _("Invalid .debug_ranges data "
12286 "(no base address)"));
12292 /* Inverted range entries are invalid. */
12293 complaint (&symfile_complaints
,
12294 _("Invalid .debug_ranges data "
12295 "(inverted range)"));
12299 /* Empty range entries have no effect. */
12303 start
+= base
+ baseaddr
;
12304 end
+= base
+ baseaddr
;
12306 /* A not-uncommon case of bad debug info.
12307 Don't pollute the addrmap with bad data. */
12308 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
12310 complaint (&symfile_complaints
,
12311 _(".debug_ranges entry has start address of zero"
12312 " [in module %s]"), objfile_name (objfile
));
12316 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
12317 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
12318 record_block_range (block
, start
, end
- 1);
12324 /* Check whether the producer field indicates either of GCC < 4.6, or the
12325 Intel C/C++ compiler, and cache the result in CU. */
12328 check_producer (struct dwarf2_cu
*cu
)
12333 if (cu
->producer
== NULL
)
12335 /* For unknown compilers expect their behavior is DWARF version
12338 GCC started to support .debug_types sections by -gdwarf-4 since
12339 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12340 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12341 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12342 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12344 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
12346 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
12347 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
12349 else if (startswith (cu
->producer
, "Intel(R) C"))
12350 cu
->producer_is_icc
= 1;
12353 /* For other non-GCC compilers, expect their behavior is DWARF version
12357 cu
->checked_producer
= 1;
12360 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12361 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12362 during 4.6.0 experimental. */
12365 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
12367 if (!cu
->checked_producer
)
12368 check_producer (cu
);
12370 return cu
->producer_is_gxx_lt_4_6
;
12373 /* Return the default accessibility type if it is not overriden by
12374 DW_AT_accessibility. */
12376 static enum dwarf_access_attribute
12377 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
12379 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
12381 /* The default DWARF 2 accessibility for members is public, the default
12382 accessibility for inheritance is private. */
12384 if (die
->tag
!= DW_TAG_inheritance
)
12385 return DW_ACCESS_public
;
12387 return DW_ACCESS_private
;
12391 /* DWARF 3+ defines the default accessibility a different way. The same
12392 rules apply now for DW_TAG_inheritance as for the members and it only
12393 depends on the container kind. */
12395 if (die
->parent
->tag
== DW_TAG_class_type
)
12396 return DW_ACCESS_private
;
12398 return DW_ACCESS_public
;
12402 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12403 offset. If the attribute was not found return 0, otherwise return
12404 1. If it was found but could not properly be handled, set *OFFSET
12408 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
12411 struct attribute
*attr
;
12413 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
12418 /* Note that we do not check for a section offset first here.
12419 This is because DW_AT_data_member_location is new in DWARF 4,
12420 so if we see it, we can assume that a constant form is really
12421 a constant and not a section offset. */
12422 if (attr_form_is_constant (attr
))
12423 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
12424 else if (attr_form_is_section_offset (attr
))
12425 dwarf2_complex_location_expr_complaint ();
12426 else if (attr_form_is_block (attr
))
12427 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12429 dwarf2_complex_location_expr_complaint ();
12437 /* Add an aggregate field to the field list. */
12440 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
12441 struct dwarf2_cu
*cu
)
12443 struct objfile
*objfile
= cu
->objfile
;
12444 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12445 struct nextfield
*new_field
;
12446 struct attribute
*attr
;
12448 const char *fieldname
= "";
12450 /* Allocate a new field list entry and link it in. */
12451 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
12452 make_cleanup (xfree
, new_field
);
12453 memset (new_field
, 0, sizeof (struct nextfield
));
12455 if (die
->tag
== DW_TAG_inheritance
)
12457 new_field
->next
= fip
->baseclasses
;
12458 fip
->baseclasses
= new_field
;
12462 new_field
->next
= fip
->fields
;
12463 fip
->fields
= new_field
;
12467 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12469 new_field
->accessibility
= DW_UNSND (attr
);
12471 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
12472 if (new_field
->accessibility
!= DW_ACCESS_public
)
12473 fip
->non_public_fields
= 1;
12475 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12477 new_field
->virtuality
= DW_UNSND (attr
);
12479 new_field
->virtuality
= DW_VIRTUALITY_none
;
12481 fp
= &new_field
->field
;
12483 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
12487 /* Data member other than a C++ static data member. */
12489 /* Get type of field. */
12490 fp
->type
= die_type (die
, cu
);
12492 SET_FIELD_BITPOS (*fp
, 0);
12494 /* Get bit size of field (zero if none). */
12495 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
12498 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
12502 FIELD_BITSIZE (*fp
) = 0;
12505 /* Get bit offset of field. */
12506 if (handle_data_member_location (die
, cu
, &offset
))
12507 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12508 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
12511 if (gdbarch_bits_big_endian (gdbarch
))
12513 /* For big endian bits, the DW_AT_bit_offset gives the
12514 additional bit offset from the MSB of the containing
12515 anonymous object to the MSB of the field. We don't
12516 have to do anything special since we don't need to
12517 know the size of the anonymous object. */
12518 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
12522 /* For little endian bits, compute the bit offset to the
12523 MSB of the anonymous object, subtract off the number of
12524 bits from the MSB of the field to the MSB of the
12525 object, and then subtract off the number of bits of
12526 the field itself. The result is the bit offset of
12527 the LSB of the field. */
12528 int anonymous_size
;
12529 int bit_offset
= DW_UNSND (attr
);
12531 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12534 /* The size of the anonymous object containing
12535 the bit field is explicit, so use the
12536 indicated size (in bytes). */
12537 anonymous_size
= DW_UNSND (attr
);
12541 /* The size of the anonymous object containing
12542 the bit field must be inferred from the type
12543 attribute of the data member containing the
12545 anonymous_size
= TYPE_LENGTH (fp
->type
);
12547 SET_FIELD_BITPOS (*fp
,
12548 (FIELD_BITPOS (*fp
)
12549 + anonymous_size
* bits_per_byte
12550 - bit_offset
- FIELD_BITSIZE (*fp
)));
12554 /* Get name of field. */
12555 fieldname
= dwarf2_name (die
, cu
);
12556 if (fieldname
== NULL
)
12559 /* The name is already allocated along with this objfile, so we don't
12560 need to duplicate it for the type. */
12561 fp
->name
= fieldname
;
12563 /* Change accessibility for artificial fields (e.g. virtual table
12564 pointer or virtual base class pointer) to private. */
12565 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
12567 FIELD_ARTIFICIAL (*fp
) = 1;
12568 new_field
->accessibility
= DW_ACCESS_private
;
12569 fip
->non_public_fields
= 1;
12572 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
12574 /* C++ static member. */
12576 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12577 is a declaration, but all versions of G++ as of this writing
12578 (so through at least 3.2.1) incorrectly generate
12579 DW_TAG_variable tags. */
12581 const char *physname
;
12583 /* Get name of field. */
12584 fieldname
= dwarf2_name (die
, cu
);
12585 if (fieldname
== NULL
)
12588 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
12590 /* Only create a symbol if this is an external value.
12591 new_symbol checks this and puts the value in the global symbol
12592 table, which we want. If it is not external, new_symbol
12593 will try to put the value in cu->list_in_scope which is wrong. */
12594 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
12596 /* A static const member, not much different than an enum as far as
12597 we're concerned, except that we can support more types. */
12598 new_symbol (die
, NULL
, cu
);
12601 /* Get physical name. */
12602 physname
= dwarf2_physname (fieldname
, die
, cu
);
12604 /* The name is already allocated along with this objfile, so we don't
12605 need to duplicate it for the type. */
12606 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
12607 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12608 FIELD_NAME (*fp
) = fieldname
;
12610 else if (die
->tag
== DW_TAG_inheritance
)
12614 /* C++ base class field. */
12615 if (handle_data_member_location (die
, cu
, &offset
))
12616 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
12617 FIELD_BITSIZE (*fp
) = 0;
12618 FIELD_TYPE (*fp
) = die_type (die
, cu
);
12619 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
12620 fip
->nbaseclasses
++;
12624 /* Add a typedef defined in the scope of the FIP's class. */
12627 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
12628 struct dwarf2_cu
*cu
)
12630 struct objfile
*objfile
= cu
->objfile
;
12631 struct typedef_field_list
*new_field
;
12632 struct attribute
*attr
;
12633 struct typedef_field
*fp
;
12634 char *fieldname
= "";
12636 /* Allocate a new field list entry and link it in. */
12637 new_field
= xzalloc (sizeof (*new_field
));
12638 make_cleanup (xfree
, new_field
);
12640 gdb_assert (die
->tag
== DW_TAG_typedef
);
12642 fp
= &new_field
->field
;
12644 /* Get name of field. */
12645 fp
->name
= dwarf2_name (die
, cu
);
12646 if (fp
->name
== NULL
)
12649 fp
->type
= read_type_die (die
, cu
);
12651 new_field
->next
= fip
->typedef_field_list
;
12652 fip
->typedef_field_list
= new_field
;
12653 fip
->typedef_field_list_count
++;
12656 /* Create the vector of fields, and attach it to the type. */
12659 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
12660 struct dwarf2_cu
*cu
)
12662 int nfields
= fip
->nfields
;
12664 /* Record the field count, allocate space for the array of fields,
12665 and create blank accessibility bitfields if necessary. */
12666 TYPE_NFIELDS (type
) = nfields
;
12667 TYPE_FIELDS (type
) = (struct field
*)
12668 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
12669 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
12671 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
12673 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12675 TYPE_FIELD_PRIVATE_BITS (type
) =
12676 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12677 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
12679 TYPE_FIELD_PROTECTED_BITS (type
) =
12680 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12681 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
12683 TYPE_FIELD_IGNORE_BITS (type
) =
12684 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
12685 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
12688 /* If the type has baseclasses, allocate and clear a bit vector for
12689 TYPE_FIELD_VIRTUAL_BITS. */
12690 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
12692 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
12693 unsigned char *pointer
;
12695 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12696 pointer
= TYPE_ALLOC (type
, num_bytes
);
12697 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
12698 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
12699 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
12702 /* Copy the saved-up fields into the field vector. Start from the head of
12703 the list, adding to the tail of the field array, so that they end up in
12704 the same order in the array in which they were added to the list. */
12705 while (nfields
-- > 0)
12707 struct nextfield
*fieldp
;
12711 fieldp
= fip
->fields
;
12712 fip
->fields
= fieldp
->next
;
12716 fieldp
= fip
->baseclasses
;
12717 fip
->baseclasses
= fieldp
->next
;
12720 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
12721 switch (fieldp
->accessibility
)
12723 case DW_ACCESS_private
:
12724 if (cu
->language
!= language_ada
)
12725 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
12728 case DW_ACCESS_protected
:
12729 if (cu
->language
!= language_ada
)
12730 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
12733 case DW_ACCESS_public
:
12737 /* Unknown accessibility. Complain and treat it as public. */
12739 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
12740 fieldp
->accessibility
);
12744 if (nfields
< fip
->nbaseclasses
)
12746 switch (fieldp
->virtuality
)
12748 case DW_VIRTUALITY_virtual
:
12749 case DW_VIRTUALITY_pure_virtual
:
12750 if (cu
->language
== language_ada
)
12751 error (_("unexpected virtuality in component of Ada type"));
12752 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
12759 /* Return true if this member function is a constructor, false
12763 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
12765 const char *fieldname
;
12766 const char *type_name
;
12769 if (die
->parent
== NULL
)
12772 if (die
->parent
->tag
!= DW_TAG_structure_type
12773 && die
->parent
->tag
!= DW_TAG_union_type
12774 && die
->parent
->tag
!= DW_TAG_class_type
)
12777 fieldname
= dwarf2_name (die
, cu
);
12778 type_name
= dwarf2_name (die
->parent
, cu
);
12779 if (fieldname
== NULL
|| type_name
== NULL
)
12782 len
= strlen (fieldname
);
12783 return (strncmp (fieldname
, type_name
, len
) == 0
12784 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
12787 /* Add a member function to the proper fieldlist. */
12790 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
12791 struct type
*type
, struct dwarf2_cu
*cu
)
12793 struct objfile
*objfile
= cu
->objfile
;
12794 struct attribute
*attr
;
12795 struct fnfieldlist
*flp
;
12797 struct fn_field
*fnp
;
12798 const char *fieldname
;
12799 struct nextfnfield
*new_fnfield
;
12800 struct type
*this_type
;
12801 enum dwarf_access_attribute accessibility
;
12803 if (cu
->language
== language_ada
)
12804 error (_("unexpected member function in Ada type"));
12806 /* Get name of member function. */
12807 fieldname
= dwarf2_name (die
, cu
);
12808 if (fieldname
== NULL
)
12811 /* Look up member function name in fieldlist. */
12812 for (i
= 0; i
< fip
->nfnfields
; i
++)
12814 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
12818 /* Create new list element if necessary. */
12819 if (i
< fip
->nfnfields
)
12820 flp
= &fip
->fnfieldlists
[i
];
12823 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
12825 fip
->fnfieldlists
= (struct fnfieldlist
*)
12826 xrealloc (fip
->fnfieldlists
,
12827 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
12828 * sizeof (struct fnfieldlist
));
12829 if (fip
->nfnfields
== 0)
12830 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
12832 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
12833 flp
->name
= fieldname
;
12836 i
= fip
->nfnfields
++;
12839 /* Create a new member function field and chain it to the field list
12841 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
12842 make_cleanup (xfree
, new_fnfield
);
12843 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
12844 new_fnfield
->next
= flp
->head
;
12845 flp
->head
= new_fnfield
;
12848 /* Fill in the member function field info. */
12849 fnp
= &new_fnfield
->fnfield
;
12851 /* Delay processing of the physname until later. */
12852 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
12854 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
12859 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
12860 fnp
->physname
= physname
? physname
: "";
12863 fnp
->type
= alloc_type (objfile
);
12864 this_type
= read_type_die (die
, cu
);
12865 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
12867 int nparams
= TYPE_NFIELDS (this_type
);
12869 /* TYPE is the domain of this method, and THIS_TYPE is the type
12870 of the method itself (TYPE_CODE_METHOD). */
12871 smash_to_method_type (fnp
->type
, type
,
12872 TYPE_TARGET_TYPE (this_type
),
12873 TYPE_FIELDS (this_type
),
12874 TYPE_NFIELDS (this_type
),
12875 TYPE_VARARGS (this_type
));
12877 /* Handle static member functions.
12878 Dwarf2 has no clean way to discern C++ static and non-static
12879 member functions. G++ helps GDB by marking the first
12880 parameter for non-static member functions (which is the this
12881 pointer) as artificial. We obtain this information from
12882 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12883 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
12884 fnp
->voffset
= VOFFSET_STATIC
;
12887 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
12888 dwarf2_full_name (fieldname
, die
, cu
));
12890 /* Get fcontext from DW_AT_containing_type if present. */
12891 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
12892 fnp
->fcontext
= die_containing_type (die
, cu
);
12894 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12895 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12897 /* Get accessibility. */
12898 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
12900 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
12902 accessibility
= dwarf2_default_access_attribute (die
, cu
);
12903 switch (accessibility
)
12905 case DW_ACCESS_private
:
12906 fnp
->is_private
= 1;
12908 case DW_ACCESS_protected
:
12909 fnp
->is_protected
= 1;
12913 /* Check for artificial methods. */
12914 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
12915 if (attr
&& DW_UNSND (attr
) != 0)
12916 fnp
->is_artificial
= 1;
12918 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
12920 /* Get index in virtual function table if it is a virtual member
12921 function. For older versions of GCC, this is an offset in the
12922 appropriate virtual table, as specified by DW_AT_containing_type.
12923 For everyone else, it is an expression to be evaluated relative
12924 to the object address. */
12926 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
12929 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
12931 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
12933 /* Old-style GCC. */
12934 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
12936 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12937 || (DW_BLOCK (attr
)->size
> 1
12938 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
12939 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
12941 struct dwarf_block blk
;
12944 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
12946 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
12947 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
12948 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
12949 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
12950 dwarf2_complex_location_expr_complaint ();
12952 fnp
->voffset
/= cu
->header
.addr_size
;
12956 dwarf2_complex_location_expr_complaint ();
12958 if (!fnp
->fcontext
)
12960 /* If there is no `this' field and no DW_AT_containing_type,
12961 we cannot actually find a base class context for the
12963 if (TYPE_NFIELDS (this_type
) == 0
12964 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
12966 complaint (&symfile_complaints
,
12967 _("cannot determine context for virtual member "
12968 "function \"%s\" (offset %d)"),
12969 fieldname
, die
->offset
.sect_off
);
12974 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
12978 else if (attr_form_is_section_offset (attr
))
12980 dwarf2_complex_location_expr_complaint ();
12984 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12990 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
12991 if (attr
&& DW_UNSND (attr
))
12993 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12994 complaint (&symfile_complaints
,
12995 _("Member function \"%s\" (offset %d) is virtual "
12996 "but the vtable offset is not specified"),
12997 fieldname
, die
->offset
.sect_off
);
12998 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
12999 TYPE_CPLUS_DYNAMIC (type
) = 1;
13004 /* Create the vector of member function fields, and attach it to the type. */
13007 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
13008 struct dwarf2_cu
*cu
)
13010 struct fnfieldlist
*flp
;
13013 if (cu
->language
== language_ada
)
13014 error (_("unexpected member functions in Ada type"));
13016 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13017 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
13018 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
13020 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
13022 struct nextfnfield
*nfp
= flp
->head
;
13023 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
13026 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
13027 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
13028 fn_flp
->fn_fields
= (struct fn_field
*)
13029 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
13030 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
13031 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
13034 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
13037 /* Returns non-zero if NAME is the name of a vtable member in CU's
13038 language, zero otherwise. */
13040 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
13042 static const char vptr
[] = "_vptr";
13043 static const char vtable
[] = "vtable";
13045 /* Look for the C++ and Java forms of the vtable. */
13046 if ((cu
->language
== language_java
13047 && startswith (name
, vtable
))
13048 || (startswith (name
, vptr
)
13049 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
13055 /* GCC outputs unnamed structures that are really pointers to member
13056 functions, with the ABI-specified layout. If TYPE describes
13057 such a structure, smash it into a member function type.
13059 GCC shouldn't do this; it should just output pointer to member DIEs.
13060 This is GCC PR debug/28767. */
13063 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
13065 struct type
*pfn_type
, *self_type
, *new_type
;
13067 /* Check for a structure with no name and two children. */
13068 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
13071 /* Check for __pfn and __delta members. */
13072 if (TYPE_FIELD_NAME (type
, 0) == NULL
13073 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
13074 || TYPE_FIELD_NAME (type
, 1) == NULL
13075 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
13078 /* Find the type of the method. */
13079 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
13080 if (pfn_type
== NULL
13081 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
13082 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
13085 /* Look for the "this" argument. */
13086 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
13087 if (TYPE_NFIELDS (pfn_type
) == 0
13088 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
13089 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
13092 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
13093 new_type
= alloc_type (objfile
);
13094 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
13095 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
13096 TYPE_VARARGS (pfn_type
));
13097 smash_to_methodptr_type (type
, new_type
);
13100 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
13104 producer_is_icc (struct dwarf2_cu
*cu
)
13106 if (!cu
->checked_producer
)
13107 check_producer (cu
);
13109 return cu
->producer_is_icc
;
13112 /* Called when we find the DIE that starts a structure or union scope
13113 (definition) to create a type for the structure or union. Fill in
13114 the type's name and general properties; the members will not be
13115 processed until process_structure_scope. A symbol table entry for
13116 the type will also not be done until process_structure_scope (assuming
13117 the type has a name).
13119 NOTE: we need to call these functions regardless of whether or not the
13120 DIE has a DW_AT_name attribute, since it might be an anonymous
13121 structure or union. This gets the type entered into our set of
13122 user defined types. */
13124 static struct type
*
13125 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13127 struct objfile
*objfile
= cu
->objfile
;
13129 struct attribute
*attr
;
13132 /* If the definition of this type lives in .debug_types, read that type.
13133 Don't follow DW_AT_specification though, that will take us back up
13134 the chain and we want to go down. */
13135 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13138 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13140 /* The type's CU may not be the same as CU.
13141 Ensure TYPE is recorded with CU in die_type_hash. */
13142 return set_die_type (die
, type
, cu
);
13145 type
= alloc_type (objfile
);
13146 INIT_CPLUS_SPECIFIC (type
);
13148 name
= dwarf2_name (die
, cu
);
13151 if (cu
->language
== language_cplus
13152 || cu
->language
== language_java
13153 || cu
->language
== language_d
)
13155 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
13157 /* dwarf2_full_name might have already finished building the DIE's
13158 type. If so, there is no need to continue. */
13159 if (get_die_type (die
, cu
) != NULL
)
13160 return get_die_type (die
, cu
);
13162 TYPE_TAG_NAME (type
) = full_name
;
13163 if (die
->tag
== DW_TAG_structure_type
13164 || die
->tag
== DW_TAG_class_type
)
13165 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13169 /* The name is already allocated along with this objfile, so
13170 we don't need to duplicate it for the type. */
13171 TYPE_TAG_NAME (type
) = name
;
13172 if (die
->tag
== DW_TAG_class_type
)
13173 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
13177 if (die
->tag
== DW_TAG_structure_type
)
13179 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13181 else if (die
->tag
== DW_TAG_union_type
)
13183 TYPE_CODE (type
) = TYPE_CODE_UNION
;
13187 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
13190 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
13191 TYPE_DECLARED_CLASS (type
) = 1;
13193 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13196 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13200 TYPE_LENGTH (type
) = 0;
13203 if (producer_is_icc (cu
) && (TYPE_LENGTH (type
) == 0))
13205 /* ICC does not output the required DW_AT_declaration
13206 on incomplete types, but gives them a size of zero. */
13207 TYPE_STUB (type
) = 1;
13210 TYPE_STUB_SUPPORTED (type
) = 1;
13212 if (die_is_declaration (die
, cu
))
13213 TYPE_STUB (type
) = 1;
13214 else if (attr
== NULL
&& die
->child
== NULL
13215 && producer_is_realview (cu
->producer
))
13216 /* RealView does not output the required DW_AT_declaration
13217 on incomplete types. */
13218 TYPE_STUB (type
) = 1;
13220 /* We need to add the type field to the die immediately so we don't
13221 infinitely recurse when dealing with pointers to the structure
13222 type within the structure itself. */
13223 set_die_type (die
, type
, cu
);
13225 /* set_die_type should be already done. */
13226 set_descriptive_type (type
, die
, cu
);
13231 /* Finish creating a structure or union type, including filling in
13232 its members and creating a symbol for it. */
13235 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13237 struct objfile
*objfile
= cu
->objfile
;
13238 struct die_info
*child_die
;
13241 type
= get_die_type (die
, cu
);
13243 type
= read_structure_type (die
, cu
);
13245 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
13247 struct field_info fi
;
13248 VEC (symbolp
) *template_args
= NULL
;
13249 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
13251 memset (&fi
, 0, sizeof (struct field_info
));
13253 child_die
= die
->child
;
13255 while (child_die
&& child_die
->tag
)
13257 if (child_die
->tag
== DW_TAG_member
13258 || child_die
->tag
== DW_TAG_variable
)
13260 /* NOTE: carlton/2002-11-05: A C++ static data member
13261 should be a DW_TAG_member that is a declaration, but
13262 all versions of G++ as of this writing (so through at
13263 least 3.2.1) incorrectly generate DW_TAG_variable
13264 tags for them instead. */
13265 dwarf2_add_field (&fi
, child_die
, cu
);
13267 else if (child_die
->tag
== DW_TAG_subprogram
)
13269 /* C++ member function. */
13270 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
13272 else if (child_die
->tag
== DW_TAG_inheritance
)
13274 /* C++ base class field. */
13275 dwarf2_add_field (&fi
, child_die
, cu
);
13277 else if (child_die
->tag
== DW_TAG_typedef
)
13278 dwarf2_add_typedef (&fi
, child_die
, cu
);
13279 else if (child_die
->tag
== DW_TAG_template_type_param
13280 || child_die
->tag
== DW_TAG_template_value_param
)
13282 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13285 VEC_safe_push (symbolp
, template_args
, arg
);
13288 child_die
= sibling_die (child_die
);
13291 /* Attach template arguments to type. */
13292 if (! VEC_empty (symbolp
, template_args
))
13294 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13295 TYPE_N_TEMPLATE_ARGUMENTS (type
)
13296 = VEC_length (symbolp
, template_args
);
13297 TYPE_TEMPLATE_ARGUMENTS (type
)
13298 = obstack_alloc (&objfile
->objfile_obstack
,
13299 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
13300 * sizeof (struct symbol
*)));
13301 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
13302 VEC_address (symbolp
, template_args
),
13303 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
13304 * sizeof (struct symbol
*)));
13305 VEC_free (symbolp
, template_args
);
13308 /* Attach fields and member functions to the type. */
13310 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
13313 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
13315 /* Get the type which refers to the base class (possibly this
13316 class itself) which contains the vtable pointer for the current
13317 class from the DW_AT_containing_type attribute. This use of
13318 DW_AT_containing_type is a GNU extension. */
13320 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
13322 struct type
*t
= die_containing_type (die
, cu
);
13324 set_type_vptr_basetype (type
, t
);
13329 /* Our own class provides vtbl ptr. */
13330 for (i
= TYPE_NFIELDS (t
) - 1;
13331 i
>= TYPE_N_BASECLASSES (t
);
13334 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
13336 if (is_vtable_name (fieldname
, cu
))
13338 set_type_vptr_fieldno (type
, i
);
13343 /* Complain if virtual function table field not found. */
13344 if (i
< TYPE_N_BASECLASSES (t
))
13345 complaint (&symfile_complaints
,
13346 _("virtual function table pointer "
13347 "not found when defining class '%s'"),
13348 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
13353 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
13356 else if (cu
->producer
13357 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
13359 /* The IBM XLC compiler does not provide direct indication
13360 of the containing type, but the vtable pointer is
13361 always named __vfp. */
13365 for (i
= TYPE_NFIELDS (type
) - 1;
13366 i
>= TYPE_N_BASECLASSES (type
);
13369 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
13371 set_type_vptr_fieldno (type
, i
);
13372 set_type_vptr_basetype (type
, type
);
13379 /* Copy fi.typedef_field_list linked list elements content into the
13380 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13381 if (fi
.typedef_field_list
)
13383 int i
= fi
.typedef_field_list_count
;
13385 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
13386 TYPE_TYPEDEF_FIELD_ARRAY (type
)
13387 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
13388 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
13390 /* Reverse the list order to keep the debug info elements order. */
13393 struct typedef_field
*dest
, *src
;
13395 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
13396 src
= &fi
.typedef_field_list
->field
;
13397 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
13402 do_cleanups (back_to
);
13404 if (HAVE_CPLUS_STRUCT (type
))
13405 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
13408 quirk_gcc_member_function_pointer (type
, objfile
);
13410 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13411 snapshots) has been known to create a die giving a declaration
13412 for a class that has, as a child, a die giving a definition for a
13413 nested class. So we have to process our children even if the
13414 current die is a declaration. Normally, of course, a declaration
13415 won't have any children at all. */
13417 child_die
= die
->child
;
13419 while (child_die
!= NULL
&& child_die
->tag
)
13421 if (child_die
->tag
== DW_TAG_member
13422 || child_die
->tag
== DW_TAG_variable
13423 || child_die
->tag
== DW_TAG_inheritance
13424 || child_die
->tag
== DW_TAG_template_value_param
13425 || child_die
->tag
== DW_TAG_template_type_param
)
13430 process_die (child_die
, cu
);
13432 child_die
= sibling_die (child_die
);
13435 /* Do not consider external references. According to the DWARF standard,
13436 these DIEs are identified by the fact that they have no byte_size
13437 attribute, and a declaration attribute. */
13438 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
13439 || !die_is_declaration (die
, cu
))
13440 new_symbol (die
, type
, cu
);
13443 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13444 update TYPE using some information only available in DIE's children. */
13447 update_enumeration_type_from_children (struct die_info
*die
,
13449 struct dwarf2_cu
*cu
)
13451 struct obstack obstack
;
13452 struct die_info
*child_die
;
13453 int unsigned_enum
= 1;
13456 struct cleanup
*old_chain
;
13458 obstack_init (&obstack
);
13459 old_chain
= make_cleanup_obstack_free (&obstack
);
13461 for (child_die
= die
->child
;
13462 child_die
!= NULL
&& child_die
->tag
;
13463 child_die
= sibling_die (child_die
))
13465 struct attribute
*attr
;
13467 const gdb_byte
*bytes
;
13468 struct dwarf2_locexpr_baton
*baton
;
13471 if (child_die
->tag
!= DW_TAG_enumerator
)
13474 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
13478 name
= dwarf2_name (child_die
, cu
);
13480 name
= "<anonymous enumerator>";
13482 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
13483 &value
, &bytes
, &baton
);
13489 else if ((mask
& value
) != 0)
13494 /* If we already know that the enum type is neither unsigned, nor
13495 a flag type, no need to look at the rest of the enumerates. */
13496 if (!unsigned_enum
&& !flag_enum
)
13501 TYPE_UNSIGNED (type
) = 1;
13503 TYPE_FLAG_ENUM (type
) = 1;
13505 do_cleanups (old_chain
);
13508 /* Given a DW_AT_enumeration_type die, set its type. We do not
13509 complete the type's fields yet, or create any symbols. */
13511 static struct type
*
13512 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13514 struct objfile
*objfile
= cu
->objfile
;
13516 struct attribute
*attr
;
13519 /* If the definition of this type lives in .debug_types, read that type.
13520 Don't follow DW_AT_specification though, that will take us back up
13521 the chain and we want to go down. */
13522 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
13525 type
= get_DW_AT_signature_type (die
, attr
, cu
);
13527 /* The type's CU may not be the same as CU.
13528 Ensure TYPE is recorded with CU in die_type_hash. */
13529 return set_die_type (die
, type
, cu
);
13532 type
= alloc_type (objfile
);
13534 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
13535 name
= dwarf2_full_name (NULL
, die
, cu
);
13537 TYPE_TAG_NAME (type
) = name
;
13539 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13542 struct type
*underlying_type
= die_type (die
, cu
);
13544 TYPE_TARGET_TYPE (type
) = underlying_type
;
13547 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13550 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13554 TYPE_LENGTH (type
) = 0;
13557 /* The enumeration DIE can be incomplete. In Ada, any type can be
13558 declared as private in the package spec, and then defined only
13559 inside the package body. Such types are known as Taft Amendment
13560 Types. When another package uses such a type, an incomplete DIE
13561 may be generated by the compiler. */
13562 if (die_is_declaration (die
, cu
))
13563 TYPE_STUB (type
) = 1;
13565 /* Finish the creation of this type by using the enum's children.
13566 We must call this even when the underlying type has been provided
13567 so that we can determine if we're looking at a "flag" enum. */
13568 update_enumeration_type_from_children (die
, type
, cu
);
13570 /* If this type has an underlying type that is not a stub, then we
13571 may use its attributes. We always use the "unsigned" attribute
13572 in this situation, because ordinarily we guess whether the type
13573 is unsigned -- but the guess can be wrong and the underlying type
13574 can tell us the reality. However, we defer to a local size
13575 attribute if one exists, because this lets the compiler override
13576 the underlying type if needed. */
13577 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
13579 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
13580 if (TYPE_LENGTH (type
) == 0)
13581 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
13584 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
13586 return set_die_type (die
, type
, cu
);
13589 /* Given a pointer to a die which begins an enumeration, process all
13590 the dies that define the members of the enumeration, and create the
13591 symbol for the enumeration type.
13593 NOTE: We reverse the order of the element list. */
13596 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13598 struct type
*this_type
;
13600 this_type
= get_die_type (die
, cu
);
13601 if (this_type
== NULL
)
13602 this_type
= read_enumeration_type (die
, cu
);
13604 if (die
->child
!= NULL
)
13606 struct die_info
*child_die
;
13607 struct symbol
*sym
;
13608 struct field
*fields
= NULL
;
13609 int num_fields
= 0;
13612 child_die
= die
->child
;
13613 while (child_die
&& child_die
->tag
)
13615 if (child_die
->tag
!= DW_TAG_enumerator
)
13617 process_die (child_die
, cu
);
13621 name
= dwarf2_name (child_die
, cu
);
13624 sym
= new_symbol (child_die
, this_type
, cu
);
13626 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
13628 fields
= (struct field
*)
13630 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
13631 * sizeof (struct field
));
13634 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
13635 FIELD_TYPE (fields
[num_fields
]) = NULL
;
13636 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
13637 FIELD_BITSIZE (fields
[num_fields
]) = 0;
13643 child_die
= sibling_die (child_die
);
13648 TYPE_NFIELDS (this_type
) = num_fields
;
13649 TYPE_FIELDS (this_type
) = (struct field
*)
13650 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
13651 memcpy (TYPE_FIELDS (this_type
), fields
,
13652 sizeof (struct field
) * num_fields
);
13657 /* If we are reading an enum from a .debug_types unit, and the enum
13658 is a declaration, and the enum is not the signatured type in the
13659 unit, then we do not want to add a symbol for it. Adding a
13660 symbol would in some cases obscure the true definition of the
13661 enum, giving users an incomplete type when the definition is
13662 actually available. Note that we do not want to do this for all
13663 enums which are just declarations, because C++0x allows forward
13664 enum declarations. */
13665 if (cu
->per_cu
->is_debug_types
13666 && die_is_declaration (die
, cu
))
13668 struct signatured_type
*sig_type
;
13670 sig_type
= (struct signatured_type
*) cu
->per_cu
;
13671 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
13672 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
13676 new_symbol (die
, this_type
, cu
);
13679 /* Extract all information from a DW_TAG_array_type DIE and put it in
13680 the DIE's type field. For now, this only handles one dimensional
13683 static struct type
*
13684 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13686 struct objfile
*objfile
= cu
->objfile
;
13687 struct die_info
*child_die
;
13689 struct type
*element_type
, *range_type
, *index_type
;
13690 struct type
**range_types
= NULL
;
13691 struct attribute
*attr
;
13693 struct cleanup
*back_to
;
13695 unsigned int bit_stride
= 0;
13697 element_type
= die_type (die
, cu
);
13699 /* The die_type call above may have already set the type for this DIE. */
13700 type
= get_die_type (die
, cu
);
13704 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
13706 bit_stride
= DW_UNSND (attr
) * 8;
13708 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
13710 bit_stride
= DW_UNSND (attr
);
13712 /* Irix 6.2 native cc creates array types without children for
13713 arrays with unspecified length. */
13714 if (die
->child
== NULL
)
13716 index_type
= objfile_type (objfile
)->builtin_int
;
13717 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
13718 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
13720 return set_die_type (die
, type
, cu
);
13723 back_to
= make_cleanup (null_cleanup
, NULL
);
13724 child_die
= die
->child
;
13725 while (child_die
&& child_die
->tag
)
13727 if (child_die
->tag
== DW_TAG_subrange_type
)
13729 struct type
*child_type
= read_type_die (child_die
, cu
);
13731 if (child_type
!= NULL
)
13733 /* The range type was succesfully read. Save it for the
13734 array type creation. */
13735 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
13737 range_types
= (struct type
**)
13738 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
13739 * sizeof (struct type
*));
13741 make_cleanup (free_current_contents
, &range_types
);
13743 range_types
[ndim
++] = child_type
;
13746 child_die
= sibling_die (child_die
);
13749 /* Dwarf2 dimensions are output from left to right, create the
13750 necessary array types in backwards order. */
13752 type
= element_type
;
13754 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
13759 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
13765 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
13769 /* Understand Dwarf2 support for vector types (like they occur on
13770 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13771 array type. This is not part of the Dwarf2/3 standard yet, but a
13772 custom vendor extension. The main difference between a regular
13773 array and the vector variant is that vectors are passed by value
13775 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
13777 make_vector_type (type
);
13779 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13780 implementation may choose to implement triple vectors using this
13782 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13785 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
13786 TYPE_LENGTH (type
) = DW_UNSND (attr
);
13788 complaint (&symfile_complaints
,
13789 _("DW_AT_byte_size for array type smaller "
13790 "than the total size of elements"));
13793 name
= dwarf2_name (die
, cu
);
13795 TYPE_NAME (type
) = name
;
13797 /* Install the type in the die. */
13798 set_die_type (die
, type
, cu
);
13800 /* set_die_type should be already done. */
13801 set_descriptive_type (type
, die
, cu
);
13803 do_cleanups (back_to
);
13808 static enum dwarf_array_dim_ordering
13809 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
13811 struct attribute
*attr
;
13813 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
13816 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
13818 /* GNU F77 is a special case, as at 08/2004 array type info is the
13819 opposite order to the dwarf2 specification, but data is still
13820 laid out as per normal fortran.
13822 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13823 version checking. */
13825 if (cu
->language
== language_fortran
13826 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
13828 return DW_ORD_row_major
;
13831 switch (cu
->language_defn
->la_array_ordering
)
13833 case array_column_major
:
13834 return DW_ORD_col_major
;
13835 case array_row_major
:
13837 return DW_ORD_row_major
;
13841 /* Extract all information from a DW_TAG_set_type DIE and put it in
13842 the DIE's type field. */
13844 static struct type
*
13845 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13847 struct type
*domain_type
, *set_type
;
13848 struct attribute
*attr
;
13850 domain_type
= die_type (die
, cu
);
13852 /* The die_type call above may have already set the type for this DIE. */
13853 set_type
= get_die_type (die
, cu
);
13857 set_type
= create_set_type (NULL
, domain_type
);
13859 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13861 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
13863 return set_die_type (die
, set_type
, cu
);
13866 /* A helper for read_common_block that creates a locexpr baton.
13867 SYM is the symbol which we are marking as computed.
13868 COMMON_DIE is the DIE for the common block.
13869 COMMON_LOC is the location expression attribute for the common
13871 MEMBER_LOC is the location expression attribute for the particular
13872 member of the common block that we are processing.
13873 CU is the CU from which the above come. */
13876 mark_common_block_symbol_computed (struct symbol
*sym
,
13877 struct die_info
*common_die
,
13878 struct attribute
*common_loc
,
13879 struct attribute
*member_loc
,
13880 struct dwarf2_cu
*cu
)
13882 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13883 struct dwarf2_locexpr_baton
*baton
;
13885 unsigned int cu_off
;
13886 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
13887 LONGEST offset
= 0;
13889 gdb_assert (common_loc
&& member_loc
);
13890 gdb_assert (attr_form_is_block (common_loc
));
13891 gdb_assert (attr_form_is_block (member_loc
)
13892 || attr_form_is_constant (member_loc
));
13894 baton
= obstack_alloc (&objfile
->objfile_obstack
,
13895 sizeof (struct dwarf2_locexpr_baton
));
13896 baton
->per_cu
= cu
->per_cu
;
13897 gdb_assert (baton
->per_cu
);
13899 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13901 if (attr_form_is_constant (member_loc
))
13903 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
13904 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
13907 baton
->size
+= DW_BLOCK (member_loc
)->size
;
13909 ptr
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
13912 *ptr
++ = DW_OP_call4
;
13913 cu_off
= common_die
->offset
.sect_off
- cu
->per_cu
->offset
.sect_off
;
13914 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
13917 if (attr_form_is_constant (member_loc
))
13919 *ptr
++ = DW_OP_addr
;
13920 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
13921 ptr
+= cu
->header
.addr_size
;
13925 /* We have to copy the data here, because DW_OP_call4 will only
13926 use a DW_AT_location attribute. */
13927 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
13928 ptr
+= DW_BLOCK (member_loc
)->size
;
13931 *ptr
++ = DW_OP_plus
;
13932 gdb_assert (ptr
- baton
->data
== baton
->size
);
13934 SYMBOL_LOCATION_BATON (sym
) = baton
;
13935 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
13938 /* Create appropriate locally-scoped variables for all the
13939 DW_TAG_common_block entries. Also create a struct common_block
13940 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13941 is used to sepate the common blocks name namespace from regular
13945 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
13947 struct attribute
*attr
;
13949 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13952 /* Support the .debug_loc offsets. */
13953 if (attr_form_is_block (attr
))
13957 else if (attr_form_is_section_offset (attr
))
13959 dwarf2_complex_location_expr_complaint ();
13964 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13965 "common block member");
13970 if (die
->child
!= NULL
)
13972 struct objfile
*objfile
= cu
->objfile
;
13973 struct die_info
*child_die
;
13974 size_t n_entries
= 0, size
;
13975 struct common_block
*common_block
;
13976 struct symbol
*sym
;
13978 for (child_die
= die
->child
;
13979 child_die
&& child_die
->tag
;
13980 child_die
= sibling_die (child_die
))
13983 size
= (sizeof (struct common_block
)
13984 + (n_entries
- 1) * sizeof (struct symbol
*));
13985 common_block
= obstack_alloc (&objfile
->objfile_obstack
, size
);
13986 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
13987 common_block
->n_entries
= 0;
13989 for (child_die
= die
->child
;
13990 child_die
&& child_die
->tag
;
13991 child_die
= sibling_die (child_die
))
13993 /* Create the symbol in the DW_TAG_common_block block in the current
13995 sym
= new_symbol (child_die
, NULL
, cu
);
13998 struct attribute
*member_loc
;
14000 common_block
->contents
[common_block
->n_entries
++] = sym
;
14002 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
14006 /* GDB has handled this for a long time, but it is
14007 not specified by DWARF. It seems to have been
14008 emitted by gfortran at least as recently as:
14009 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
14010 complaint (&symfile_complaints
,
14011 _("Variable in common block has "
14012 "DW_AT_data_member_location "
14013 "- DIE at 0x%x [in module %s]"),
14014 child_die
->offset
.sect_off
,
14015 objfile_name (cu
->objfile
));
14017 if (attr_form_is_section_offset (member_loc
))
14018 dwarf2_complex_location_expr_complaint ();
14019 else if (attr_form_is_constant (member_loc
)
14020 || attr_form_is_block (member_loc
))
14023 mark_common_block_symbol_computed (sym
, die
, attr
,
14027 dwarf2_complex_location_expr_complaint ();
14032 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
14033 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
14037 /* Create a type for a C++ namespace. */
14039 static struct type
*
14040 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14042 struct objfile
*objfile
= cu
->objfile
;
14043 const char *previous_prefix
, *name
;
14047 /* For extensions, reuse the type of the original namespace. */
14048 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
14050 struct die_info
*ext_die
;
14051 struct dwarf2_cu
*ext_cu
= cu
;
14053 ext_die
= dwarf2_extension (die
, &ext_cu
);
14054 type
= read_type_die (ext_die
, ext_cu
);
14056 /* EXT_CU may not be the same as CU.
14057 Ensure TYPE is recorded with CU in die_type_hash. */
14058 return set_die_type (die
, type
, cu
);
14061 name
= namespace_name (die
, &is_anonymous
, cu
);
14063 /* Now build the name of the current namespace. */
14065 previous_prefix
= determine_prefix (die
, cu
);
14066 if (previous_prefix
[0] != '\0')
14067 name
= typename_concat (&objfile
->objfile_obstack
,
14068 previous_prefix
, name
, 0, cu
);
14070 /* Create the type. */
14071 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
14073 TYPE_NAME (type
) = name
;
14074 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14076 return set_die_type (die
, type
, cu
);
14079 /* Read a C++ namespace. */
14082 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
14084 struct objfile
*objfile
= cu
->objfile
;
14087 /* Add a symbol associated to this if we haven't seen the namespace
14088 before. Also, add a using directive if it's an anonymous
14091 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
14095 type
= read_type_die (die
, cu
);
14096 new_symbol (die
, type
, cu
);
14098 namespace_name (die
, &is_anonymous
, cu
);
14101 const char *previous_prefix
= determine_prefix (die
, cu
);
14103 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
14104 NULL
, NULL
, 0, &objfile
->objfile_obstack
);
14108 if (die
->child
!= NULL
)
14110 struct die_info
*child_die
= die
->child
;
14112 while (child_die
&& child_die
->tag
)
14114 process_die (child_die
, cu
);
14115 child_die
= sibling_die (child_die
);
14120 /* Read a Fortran module as type. This DIE can be only a declaration used for
14121 imported module. Still we need that type as local Fortran "use ... only"
14122 declaration imports depend on the created type in determine_prefix. */
14124 static struct type
*
14125 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14127 struct objfile
*objfile
= cu
->objfile
;
14128 const char *module_name
;
14131 module_name
= dwarf2_name (die
, cu
);
14133 complaint (&symfile_complaints
,
14134 _("DW_TAG_module has no name, offset 0x%x"),
14135 die
->offset
.sect_off
);
14136 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
14138 /* determine_prefix uses TYPE_TAG_NAME. */
14139 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14141 return set_die_type (die
, type
, cu
);
14144 /* Read a Fortran module. */
14147 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
14149 struct die_info
*child_die
= die
->child
;
14152 type
= read_type_die (die
, cu
);
14153 new_symbol (die
, type
, cu
);
14155 while (child_die
&& child_die
->tag
)
14157 process_die (child_die
, cu
);
14158 child_die
= sibling_die (child_die
);
14162 /* Return the name of the namespace represented by DIE. Set
14163 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
14166 static const char *
14167 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
14169 struct die_info
*current_die
;
14170 const char *name
= NULL
;
14172 /* Loop through the extensions until we find a name. */
14174 for (current_die
= die
;
14175 current_die
!= NULL
;
14176 current_die
= dwarf2_extension (die
, &cu
))
14178 /* We don't use dwarf2_name here so that we can detect the absence
14179 of a name -> anonymous namespace. */
14180 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
14183 name
= DW_STRING (attr
);
14188 /* Is it an anonymous namespace? */
14190 *is_anonymous
= (name
== NULL
);
14192 name
= CP_ANONYMOUS_NAMESPACE_STR
;
14197 /* Extract all information from a DW_TAG_pointer_type DIE and add to
14198 the user defined type vector. */
14200 static struct type
*
14201 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14203 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
14204 struct comp_unit_head
*cu_header
= &cu
->header
;
14206 struct attribute
*attr_byte_size
;
14207 struct attribute
*attr_address_class
;
14208 int byte_size
, addr_class
;
14209 struct type
*target_type
;
14211 target_type
= die_type (die
, cu
);
14213 /* The die_type call above may have already set the type for this DIE. */
14214 type
= get_die_type (die
, cu
);
14218 type
= lookup_pointer_type (target_type
);
14220 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14221 if (attr_byte_size
)
14222 byte_size
= DW_UNSND (attr_byte_size
);
14224 byte_size
= cu_header
->addr_size
;
14226 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
14227 if (attr_address_class
)
14228 addr_class
= DW_UNSND (attr_address_class
);
14230 addr_class
= DW_ADDR_none
;
14232 /* If the pointer size or address class is different than the
14233 default, create a type variant marked as such and set the
14234 length accordingly. */
14235 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
14237 if (gdbarch_address_class_type_flags_p (gdbarch
))
14241 type_flags
= gdbarch_address_class_type_flags
14242 (gdbarch
, byte_size
, addr_class
);
14243 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
14245 type
= make_type_with_address_space (type
, type_flags
);
14247 else if (TYPE_LENGTH (type
) != byte_size
)
14249 complaint (&symfile_complaints
,
14250 _("invalid pointer size %d"), byte_size
);
14254 /* Should we also complain about unhandled address classes? */
14258 TYPE_LENGTH (type
) = byte_size
;
14259 return set_die_type (die
, type
, cu
);
14262 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14263 the user defined type vector. */
14265 static struct type
*
14266 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14269 struct type
*to_type
;
14270 struct type
*domain
;
14272 to_type
= die_type (die
, cu
);
14273 domain
= die_containing_type (die
, cu
);
14275 /* The calls above may have already set the type for this DIE. */
14276 type
= get_die_type (die
, cu
);
14280 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
14281 type
= lookup_methodptr_type (to_type
);
14282 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
14284 struct type
*new_type
= alloc_type (cu
->objfile
);
14286 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
14287 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
14288 TYPE_VARARGS (to_type
));
14289 type
= lookup_methodptr_type (new_type
);
14292 type
= lookup_memberptr_type (to_type
, domain
);
14294 return set_die_type (die
, type
, cu
);
14297 /* Extract all information from a DW_TAG_reference_type DIE and add to
14298 the user defined type vector. */
14300 static struct type
*
14301 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14303 struct comp_unit_head
*cu_header
= &cu
->header
;
14304 struct type
*type
, *target_type
;
14305 struct attribute
*attr
;
14307 target_type
= die_type (die
, cu
);
14309 /* The die_type call above may have already set the type for this DIE. */
14310 type
= get_die_type (die
, cu
);
14314 type
= lookup_reference_type (target_type
);
14315 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14318 TYPE_LENGTH (type
) = DW_UNSND (attr
);
14322 TYPE_LENGTH (type
) = cu_header
->addr_size
;
14324 return set_die_type (die
, type
, cu
);
14327 /* Add the given cv-qualifiers to the element type of the array. GCC
14328 outputs DWARF type qualifiers that apply to an array, not the
14329 element type. But GDB relies on the array element type to carry
14330 the cv-qualifiers. This mimics section 6.7.3 of the C99
14333 static struct type
*
14334 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
14335 struct type
*base_type
, int cnst
, int voltl
)
14337 struct type
*el_type
, *inner_array
;
14339 base_type
= copy_type (base_type
);
14340 inner_array
= base_type
;
14342 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
14344 TYPE_TARGET_TYPE (inner_array
) =
14345 copy_type (TYPE_TARGET_TYPE (inner_array
));
14346 inner_array
= TYPE_TARGET_TYPE (inner_array
);
14349 el_type
= TYPE_TARGET_TYPE (inner_array
);
14350 cnst
|= TYPE_CONST (el_type
);
14351 voltl
|= TYPE_VOLATILE (el_type
);
14352 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
14354 return set_die_type (die
, base_type
, cu
);
14357 static struct type
*
14358 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14360 struct type
*base_type
, *cv_type
;
14362 base_type
= die_type (die
, cu
);
14364 /* The die_type call above may have already set the type for this DIE. */
14365 cv_type
= get_die_type (die
, cu
);
14369 /* In case the const qualifier is applied to an array type, the element type
14370 is so qualified, not the array type (section 6.7.3 of C99). */
14371 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14372 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
14374 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
14375 return set_die_type (die
, cv_type
, cu
);
14378 static struct type
*
14379 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14381 struct type
*base_type
, *cv_type
;
14383 base_type
= die_type (die
, cu
);
14385 /* The die_type call above may have already set the type for this DIE. */
14386 cv_type
= get_die_type (die
, cu
);
14390 /* In case the volatile qualifier is applied to an array type, the
14391 element type is so qualified, not the array type (section 6.7.3
14393 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14394 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
14396 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
14397 return set_die_type (die
, cv_type
, cu
);
14400 /* Handle DW_TAG_restrict_type. */
14402 static struct type
*
14403 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14405 struct type
*base_type
, *cv_type
;
14407 base_type
= die_type (die
, cu
);
14409 /* The die_type call above may have already set the type for this DIE. */
14410 cv_type
= get_die_type (die
, cu
);
14414 cv_type
= make_restrict_type (base_type
);
14415 return set_die_type (die
, cv_type
, cu
);
14418 /* Handle DW_TAG_atomic_type. */
14420 static struct type
*
14421 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14423 struct type
*base_type
, *cv_type
;
14425 base_type
= die_type (die
, cu
);
14427 /* The die_type call above may have already set the type for this DIE. */
14428 cv_type
= get_die_type (die
, cu
);
14432 cv_type
= make_atomic_type (base_type
);
14433 return set_die_type (die
, cv_type
, cu
);
14436 /* Extract all information from a DW_TAG_string_type DIE and add to
14437 the user defined type vector. It isn't really a user defined type,
14438 but it behaves like one, with other DIE's using an AT_user_def_type
14439 attribute to reference it. */
14441 static struct type
*
14442 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14444 struct objfile
*objfile
= cu
->objfile
;
14445 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14446 struct type
*type
, *range_type
, *index_type
, *char_type
;
14447 struct attribute
*attr
;
14448 unsigned int length
;
14450 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
14453 length
= DW_UNSND (attr
);
14457 /* Check for the DW_AT_byte_size attribute. */
14458 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14461 length
= DW_UNSND (attr
);
14469 index_type
= objfile_type (objfile
)->builtin_int
;
14470 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
14471 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
14472 type
= create_string_type (NULL
, char_type
, range_type
);
14474 return set_die_type (die
, type
, cu
);
14477 /* Assuming that DIE corresponds to a function, returns nonzero
14478 if the function is prototyped. */
14481 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
14483 struct attribute
*attr
;
14485 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
14486 if (attr
&& (DW_UNSND (attr
) != 0))
14489 /* The DWARF standard implies that the DW_AT_prototyped attribute
14490 is only meaninful for C, but the concept also extends to other
14491 languages that allow unprototyped functions (Eg: Objective C).
14492 For all other languages, assume that functions are always
14494 if (cu
->language
!= language_c
14495 && cu
->language
!= language_objc
14496 && cu
->language
!= language_opencl
)
14499 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14500 prototyped and unprototyped functions; default to prototyped,
14501 since that is more common in modern code (and RealView warns
14502 about unprototyped functions). */
14503 if (producer_is_realview (cu
->producer
))
14509 /* Handle DIES due to C code like:
14513 int (*funcp)(int a, long l);
14517 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14519 static struct type
*
14520 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14522 struct objfile
*objfile
= cu
->objfile
;
14523 struct type
*type
; /* Type that this function returns. */
14524 struct type
*ftype
; /* Function that returns above type. */
14525 struct attribute
*attr
;
14527 type
= die_type (die
, cu
);
14529 /* The die_type call above may have already set the type for this DIE. */
14530 ftype
= get_die_type (die
, cu
);
14534 ftype
= lookup_function_type (type
);
14536 if (prototyped_function_p (die
, cu
))
14537 TYPE_PROTOTYPED (ftype
) = 1;
14539 /* Store the calling convention in the type if it's available in
14540 the subroutine die. Otherwise set the calling convention to
14541 the default value DW_CC_normal. */
14542 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
14544 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
14545 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
14546 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
14548 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
14550 /* Record whether the function returns normally to its caller or not
14551 if the DWARF producer set that information. */
14552 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
14553 if (attr
&& (DW_UNSND (attr
) != 0))
14554 TYPE_NO_RETURN (ftype
) = 1;
14556 /* We need to add the subroutine type to the die immediately so
14557 we don't infinitely recurse when dealing with parameters
14558 declared as the same subroutine type. */
14559 set_die_type (die
, ftype
, cu
);
14561 if (die
->child
!= NULL
)
14563 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
14564 struct die_info
*child_die
;
14565 int nparams
, iparams
;
14567 /* Count the number of parameters.
14568 FIXME: GDB currently ignores vararg functions, but knows about
14569 vararg member functions. */
14571 child_die
= die
->child
;
14572 while (child_die
&& child_die
->tag
)
14574 if (child_die
->tag
== DW_TAG_formal_parameter
)
14576 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
14577 TYPE_VARARGS (ftype
) = 1;
14578 child_die
= sibling_die (child_die
);
14581 /* Allocate storage for parameters and fill them in. */
14582 TYPE_NFIELDS (ftype
) = nparams
;
14583 TYPE_FIELDS (ftype
) = (struct field
*)
14584 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
14586 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14587 even if we error out during the parameters reading below. */
14588 for (iparams
= 0; iparams
< nparams
; iparams
++)
14589 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
14592 child_die
= die
->child
;
14593 while (child_die
&& child_die
->tag
)
14595 if (child_die
->tag
== DW_TAG_formal_parameter
)
14597 struct type
*arg_type
;
14599 /* DWARF version 2 has no clean way to discern C++
14600 static and non-static member functions. G++ helps
14601 GDB by marking the first parameter for non-static
14602 member functions (which is the this pointer) as
14603 artificial. We pass this information to
14604 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14606 DWARF version 3 added DW_AT_object_pointer, which GCC
14607 4.5 does not yet generate. */
14608 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
14610 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
14613 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
14615 /* GCC/43521: In java, the formal parameter
14616 "this" is sometimes not marked with DW_AT_artificial. */
14617 if (cu
->language
== language_java
)
14619 const char *name
= dwarf2_name (child_die
, cu
);
14621 if (name
&& !strcmp (name
, "this"))
14622 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
14625 arg_type
= die_type (child_die
, cu
);
14627 /* RealView does not mark THIS as const, which the testsuite
14628 expects. GCC marks THIS as const in method definitions,
14629 but not in the class specifications (GCC PR 43053). */
14630 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
14631 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
14634 struct dwarf2_cu
*arg_cu
= cu
;
14635 const char *name
= dwarf2_name (child_die
, cu
);
14637 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
14640 /* If the compiler emits this, use it. */
14641 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
14644 else if (name
&& strcmp (name
, "this") == 0)
14645 /* Function definitions will have the argument names. */
14647 else if (name
== NULL
&& iparams
== 0)
14648 /* Declarations may not have the names, so like
14649 elsewhere in GDB, assume an artificial first
14650 argument is "this". */
14654 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
14658 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
14661 child_die
= sibling_die (child_die
);
14668 static struct type
*
14669 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
14671 struct objfile
*objfile
= cu
->objfile
;
14672 const char *name
= NULL
;
14673 struct type
*this_type
, *target_type
;
14675 name
= dwarf2_full_name (NULL
, die
, cu
);
14676 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
14677 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
14678 TYPE_NAME (this_type
) = name
;
14679 set_die_type (die
, this_type
, cu
);
14680 target_type
= die_type (die
, cu
);
14681 if (target_type
!= this_type
)
14682 TYPE_TARGET_TYPE (this_type
) = target_type
;
14685 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14686 spec and cause infinite loops in GDB. */
14687 complaint (&symfile_complaints
,
14688 _("Self-referential DW_TAG_typedef "
14689 "- DIE at 0x%x [in module %s]"),
14690 die
->offset
.sect_off
, objfile_name (objfile
));
14691 TYPE_TARGET_TYPE (this_type
) = NULL
;
14696 /* Find a representation of a given base type and install
14697 it in the TYPE field of the die. */
14699 static struct type
*
14700 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14702 struct objfile
*objfile
= cu
->objfile
;
14704 struct attribute
*attr
;
14705 int encoding
= 0, size
= 0;
14707 enum type_code code
= TYPE_CODE_INT
;
14708 int type_flags
= 0;
14709 struct type
*target_type
= NULL
;
14711 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
14714 encoding
= DW_UNSND (attr
);
14716 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14719 size
= DW_UNSND (attr
);
14721 name
= dwarf2_name (die
, cu
);
14724 complaint (&symfile_complaints
,
14725 _("DW_AT_name missing from DW_TAG_base_type"));
14730 case DW_ATE_address
:
14731 /* Turn DW_ATE_address into a void * pointer. */
14732 code
= TYPE_CODE_PTR
;
14733 type_flags
|= TYPE_FLAG_UNSIGNED
;
14734 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
14736 case DW_ATE_boolean
:
14737 code
= TYPE_CODE_BOOL
;
14738 type_flags
|= TYPE_FLAG_UNSIGNED
;
14740 case DW_ATE_complex_float
:
14741 code
= TYPE_CODE_COMPLEX
;
14742 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
14744 case DW_ATE_decimal_float
:
14745 code
= TYPE_CODE_DECFLOAT
;
14748 code
= TYPE_CODE_FLT
;
14750 case DW_ATE_signed
:
14752 case DW_ATE_unsigned
:
14753 type_flags
|= TYPE_FLAG_UNSIGNED
;
14754 if (cu
->language
== language_fortran
14756 && startswith (name
, "character("))
14757 code
= TYPE_CODE_CHAR
;
14759 case DW_ATE_signed_char
:
14760 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14761 || cu
->language
== language_pascal
14762 || cu
->language
== language_fortran
)
14763 code
= TYPE_CODE_CHAR
;
14765 case DW_ATE_unsigned_char
:
14766 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14767 || cu
->language
== language_pascal
14768 || cu
->language
== language_fortran
)
14769 code
= TYPE_CODE_CHAR
;
14770 type_flags
|= TYPE_FLAG_UNSIGNED
;
14773 /* We just treat this as an integer and then recognize the
14774 type by name elsewhere. */
14778 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
14779 dwarf_type_encoding_name (encoding
));
14783 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
14784 TYPE_NAME (type
) = name
;
14785 TYPE_TARGET_TYPE (type
) = target_type
;
14787 if (name
&& strcmp (name
, "char") == 0)
14788 TYPE_NOSIGN (type
) = 1;
14790 return set_die_type (die
, type
, cu
);
14793 /* Parse dwarf attribute if it's a block, reference or constant and put the
14794 resulting value of the attribute into struct bound_prop.
14795 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14798 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
14799 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
14801 struct dwarf2_property_baton
*baton
;
14802 struct obstack
*obstack
= &cu
->objfile
->objfile_obstack
;
14804 if (attr
== NULL
|| prop
== NULL
)
14807 if (attr_form_is_block (attr
))
14809 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14810 baton
->referenced_type
= NULL
;
14811 baton
->locexpr
.per_cu
= cu
->per_cu
;
14812 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
14813 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
14814 prop
->data
.baton
= baton
;
14815 prop
->kind
= PROP_LOCEXPR
;
14816 gdb_assert (prop
->data
.baton
!= NULL
);
14818 else if (attr_form_is_ref (attr
))
14820 struct dwarf2_cu
*target_cu
= cu
;
14821 struct die_info
*target_die
;
14822 struct attribute
*target_attr
;
14824 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14825 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
14826 if (target_attr
== NULL
)
14827 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
14829 if (target_attr
== NULL
)
14832 switch (target_attr
->name
)
14834 case DW_AT_location
:
14835 if (attr_form_is_section_offset (target_attr
))
14837 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14838 baton
->referenced_type
= die_type (target_die
, target_cu
);
14839 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
14840 prop
->data
.baton
= baton
;
14841 prop
->kind
= PROP_LOCLIST
;
14842 gdb_assert (prop
->data
.baton
!= NULL
);
14844 else if (attr_form_is_block (target_attr
))
14846 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14847 baton
->referenced_type
= die_type (target_die
, target_cu
);
14848 baton
->locexpr
.per_cu
= cu
->per_cu
;
14849 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
14850 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
14851 prop
->data
.baton
= baton
;
14852 prop
->kind
= PROP_LOCEXPR
;
14853 gdb_assert (prop
->data
.baton
!= NULL
);
14857 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14858 "dynamic property");
14862 case DW_AT_data_member_location
:
14866 if (!handle_data_member_location (target_die
, target_cu
,
14870 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14871 baton
->referenced_type
= read_type_die (target_die
->parent
,
14873 baton
->offset_info
.offset
= offset
;
14874 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
14875 prop
->data
.baton
= baton
;
14876 prop
->kind
= PROP_ADDR_OFFSET
;
14881 else if (attr_form_is_constant (attr
))
14883 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
14884 prop
->kind
= PROP_CONST
;
14888 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
14889 dwarf2_name (die
, cu
));
14896 /* Read the given DW_AT_subrange DIE. */
14898 static struct type
*
14899 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14901 struct type
*base_type
, *orig_base_type
;
14902 struct type
*range_type
;
14903 struct attribute
*attr
;
14904 struct dynamic_prop low
, high
;
14905 int low_default_is_valid
;
14906 int high_bound_is_count
= 0;
14908 LONGEST negative_mask
;
14910 orig_base_type
= die_type (die
, cu
);
14911 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14912 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14913 creating the range type, but we use the result of check_typedef
14914 when examining properties of the type. */
14915 base_type
= check_typedef (orig_base_type
);
14917 /* The die_type call above may have already set the type for this DIE. */
14918 range_type
= get_die_type (die
, cu
);
14922 low
.kind
= PROP_CONST
;
14923 high
.kind
= PROP_CONST
;
14924 high
.data
.const_val
= 0;
14926 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14927 omitting DW_AT_lower_bound. */
14928 switch (cu
->language
)
14931 case language_cplus
:
14932 low
.data
.const_val
= 0;
14933 low_default_is_valid
= 1;
14935 case language_fortran
:
14936 low
.data
.const_val
= 1;
14937 low_default_is_valid
= 1;
14940 case language_java
:
14941 case language_objc
:
14942 low
.data
.const_val
= 0;
14943 low_default_is_valid
= (cu
->header
.version
>= 4);
14947 case language_pascal
:
14948 low
.data
.const_val
= 1;
14949 low_default_is_valid
= (cu
->header
.version
>= 4);
14952 low
.data
.const_val
= 0;
14953 low_default_is_valid
= 0;
14957 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
14959 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
14960 else if (!low_default_is_valid
)
14961 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
14962 "- DIE at 0x%x [in module %s]"),
14963 die
->offset
.sect_off
, objfile_name (cu
->objfile
));
14965 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
14966 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14968 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
14969 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14971 /* If bounds are constant do the final calculation here. */
14972 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
14973 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
14975 high_bound_is_count
= 1;
14979 /* Dwarf-2 specifications explicitly allows to create subrange types
14980 without specifying a base type.
14981 In that case, the base type must be set to the type of
14982 the lower bound, upper bound or count, in that order, if any of these
14983 three attributes references an object that has a type.
14984 If no base type is found, the Dwarf-2 specifications say that
14985 a signed integer type of size equal to the size of an address should
14987 For the following C code: `extern char gdb_int [];'
14988 GCC produces an empty range DIE.
14989 FIXME: muller/2010-05-28: Possible references to object for low bound,
14990 high bound or count are not yet handled by this code. */
14991 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
14993 struct objfile
*objfile
= cu
->objfile
;
14994 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14995 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
14996 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
14998 /* Test "int", "long int", and "long long int" objfile types,
14999 and select the first one having a size above or equal to the
15000 architecture address size. */
15001 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15002 base_type
= int_type
;
15005 int_type
= objfile_type (objfile
)->builtin_long
;
15006 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15007 base_type
= int_type
;
15010 int_type
= objfile_type (objfile
)->builtin_long_long
;
15011 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15012 base_type
= int_type
;
15017 /* Normally, the DWARF producers are expected to use a signed
15018 constant form (Eg. DW_FORM_sdata) to express negative bounds.
15019 But this is unfortunately not always the case, as witnessed
15020 with GCC, for instance, where the ambiguous DW_FORM_dataN form
15021 is used instead. To work around that ambiguity, we treat
15022 the bounds as signed, and thus sign-extend their values, when
15023 the base type is signed. */
15025 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
15026 if (low
.kind
== PROP_CONST
15027 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
15028 low
.data
.const_val
|= negative_mask
;
15029 if (high
.kind
== PROP_CONST
15030 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
15031 high
.data
.const_val
|= negative_mask
;
15033 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
15035 if (high_bound_is_count
)
15036 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
15038 /* Ada expects an empty array on no boundary attributes. */
15039 if (attr
== NULL
&& cu
->language
!= language_ada
)
15040 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
15042 name
= dwarf2_name (die
, cu
);
15044 TYPE_NAME (range_type
) = name
;
15046 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15048 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
15050 set_die_type (die
, range_type
, cu
);
15052 /* set_die_type should be already done. */
15053 set_descriptive_type (range_type
, die
, cu
);
15058 static struct type
*
15059 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15063 /* For now, we only support the C meaning of an unspecified type: void. */
15065 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
15066 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
15068 return set_die_type (die
, type
, cu
);
15071 /* Read a single die and all its descendents. Set the die's sibling
15072 field to NULL; set other fields in the die correctly, and set all
15073 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
15074 location of the info_ptr after reading all of those dies. PARENT
15075 is the parent of the die in question. */
15077 static struct die_info
*
15078 read_die_and_children (const struct die_reader_specs
*reader
,
15079 const gdb_byte
*info_ptr
,
15080 const gdb_byte
**new_info_ptr
,
15081 struct die_info
*parent
)
15083 struct die_info
*die
;
15084 const gdb_byte
*cur_ptr
;
15087 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
15090 *new_info_ptr
= cur_ptr
;
15093 store_in_ref_table (die
, reader
->cu
);
15096 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
15100 *new_info_ptr
= cur_ptr
;
15103 die
->sibling
= NULL
;
15104 die
->parent
= parent
;
15108 /* Read a die, all of its descendents, and all of its siblings; set
15109 all of the fields of all of the dies correctly. Arguments are as
15110 in read_die_and_children. */
15112 static struct die_info
*
15113 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
15114 const gdb_byte
*info_ptr
,
15115 const gdb_byte
**new_info_ptr
,
15116 struct die_info
*parent
)
15118 struct die_info
*first_die
, *last_sibling
;
15119 const gdb_byte
*cur_ptr
;
15121 cur_ptr
= info_ptr
;
15122 first_die
= last_sibling
= NULL
;
15126 struct die_info
*die
15127 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
15131 *new_info_ptr
= cur_ptr
;
15138 last_sibling
->sibling
= die
;
15140 last_sibling
= die
;
15144 /* Read a die, all of its descendents, and all of its siblings; set
15145 all of the fields of all of the dies correctly. Arguments are as
15146 in read_die_and_children.
15147 This the main entry point for reading a DIE and all its children. */
15149 static struct die_info
*
15150 read_die_and_siblings (const struct die_reader_specs
*reader
,
15151 const gdb_byte
*info_ptr
,
15152 const gdb_byte
**new_info_ptr
,
15153 struct die_info
*parent
)
15155 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
15156 new_info_ptr
, parent
);
15158 if (dwarf_die_debug
)
15160 fprintf_unfiltered (gdb_stdlog
,
15161 "Read die from %s@0x%x of %s:\n",
15162 get_section_name (reader
->die_section
),
15163 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15164 bfd_get_filename (reader
->abfd
));
15165 dump_die (die
, dwarf_die_debug
);
15171 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
15173 The caller is responsible for filling in the extra attributes
15174 and updating (*DIEP)->num_attrs.
15175 Set DIEP to point to a newly allocated die with its information,
15176 except for its child, sibling, and parent fields.
15177 Set HAS_CHILDREN to tell whether the die has children or not. */
15179 static const gdb_byte
*
15180 read_full_die_1 (const struct die_reader_specs
*reader
,
15181 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15182 int *has_children
, int num_extra_attrs
)
15184 unsigned int abbrev_number
, bytes_read
, i
;
15185 sect_offset offset
;
15186 struct abbrev_info
*abbrev
;
15187 struct die_info
*die
;
15188 struct dwarf2_cu
*cu
= reader
->cu
;
15189 bfd
*abfd
= reader
->abfd
;
15191 offset
.sect_off
= info_ptr
- reader
->buffer
;
15192 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15193 info_ptr
+= bytes_read
;
15194 if (!abbrev_number
)
15201 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
15203 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
15205 bfd_get_filename (abfd
));
15207 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
15208 die
->offset
= offset
;
15209 die
->tag
= abbrev
->tag
;
15210 die
->abbrev
= abbrev_number
;
15212 /* Make the result usable.
15213 The caller needs to update num_attrs after adding the extra
15215 die
->num_attrs
= abbrev
->num_attrs
;
15217 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15218 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
15222 *has_children
= abbrev
->has_children
;
15226 /* Read a die and all its attributes.
15227 Set DIEP to point to a newly allocated die with its information,
15228 except for its child, sibling, and parent fields.
15229 Set HAS_CHILDREN to tell whether the die has children or not. */
15231 static const gdb_byte
*
15232 read_full_die (const struct die_reader_specs
*reader
,
15233 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15236 const gdb_byte
*result
;
15238 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
15240 if (dwarf_die_debug
)
15242 fprintf_unfiltered (gdb_stdlog
,
15243 "Read die from %s@0x%x of %s:\n",
15244 get_section_name (reader
->die_section
),
15245 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15246 bfd_get_filename (reader
->abfd
));
15247 dump_die (*diep
, dwarf_die_debug
);
15253 /* Abbreviation tables.
15255 In DWARF version 2, the description of the debugging information is
15256 stored in a separate .debug_abbrev section. Before we read any
15257 dies from a section we read in all abbreviations and install them
15258 in a hash table. */
15260 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
15262 static struct abbrev_info
*
15263 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
15265 struct abbrev_info
*abbrev
;
15267 abbrev
= (struct abbrev_info
*)
15268 obstack_alloc (&abbrev_table
->abbrev_obstack
, sizeof (struct abbrev_info
));
15269 memset (abbrev
, 0, sizeof (struct abbrev_info
));
15273 /* Add an abbreviation to the table. */
15276 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
15277 unsigned int abbrev_number
,
15278 struct abbrev_info
*abbrev
)
15280 unsigned int hash_number
;
15282 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15283 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
15284 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
15287 /* Look up an abbrev in the table.
15288 Returns NULL if the abbrev is not found. */
15290 static struct abbrev_info
*
15291 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
15292 unsigned int abbrev_number
)
15294 unsigned int hash_number
;
15295 struct abbrev_info
*abbrev
;
15297 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15298 abbrev
= abbrev_table
->abbrevs
[hash_number
];
15302 if (abbrev
->number
== abbrev_number
)
15304 abbrev
= abbrev
->next
;
15309 /* Read in an abbrev table. */
15311 static struct abbrev_table
*
15312 abbrev_table_read_table (struct dwarf2_section_info
*section
,
15313 sect_offset offset
)
15315 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15316 bfd
*abfd
= get_section_bfd_owner (section
);
15317 struct abbrev_table
*abbrev_table
;
15318 const gdb_byte
*abbrev_ptr
;
15319 struct abbrev_info
*cur_abbrev
;
15320 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
15321 unsigned int abbrev_form
;
15322 struct attr_abbrev
*cur_attrs
;
15323 unsigned int allocated_attrs
;
15325 abbrev_table
= XNEW (struct abbrev_table
);
15326 abbrev_table
->offset
= offset
;
15327 obstack_init (&abbrev_table
->abbrev_obstack
);
15328 abbrev_table
->abbrevs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15330 * sizeof (struct abbrev_info
*)));
15331 memset (abbrev_table
->abbrevs
, 0,
15332 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
15334 dwarf2_read_section (objfile
, section
);
15335 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
15336 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15337 abbrev_ptr
+= bytes_read
;
15339 allocated_attrs
= ATTR_ALLOC_CHUNK
;
15340 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
15342 /* Loop until we reach an abbrev number of 0. */
15343 while (abbrev_number
)
15345 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
15347 /* read in abbrev header */
15348 cur_abbrev
->number
= abbrev_number
;
15350 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15351 abbrev_ptr
+= bytes_read
;
15352 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
15355 /* now read in declarations */
15356 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15357 abbrev_ptr
+= bytes_read
;
15358 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15359 abbrev_ptr
+= bytes_read
;
15360 while (abbrev_name
)
15362 if (cur_abbrev
->num_attrs
== allocated_attrs
)
15364 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
15366 = xrealloc (cur_attrs
, (allocated_attrs
15367 * sizeof (struct attr_abbrev
)));
15370 cur_attrs
[cur_abbrev
->num_attrs
].name
15371 = (enum dwarf_attribute
) abbrev_name
;
15372 cur_attrs
[cur_abbrev
->num_attrs
++].form
15373 = (enum dwarf_form
) abbrev_form
;
15374 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15375 abbrev_ptr
+= bytes_read
;
15376 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15377 abbrev_ptr
+= bytes_read
;
15380 cur_abbrev
->attrs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15381 (cur_abbrev
->num_attrs
15382 * sizeof (struct attr_abbrev
)));
15383 memcpy (cur_abbrev
->attrs
, cur_attrs
,
15384 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
15386 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
15388 /* Get next abbreviation.
15389 Under Irix6 the abbreviations for a compilation unit are not
15390 always properly terminated with an abbrev number of 0.
15391 Exit loop if we encounter an abbreviation which we have
15392 already read (which means we are about to read the abbreviations
15393 for the next compile unit) or if the end of the abbreviation
15394 table is reached. */
15395 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
15397 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15398 abbrev_ptr
+= bytes_read
;
15399 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
15404 return abbrev_table
;
15407 /* Free the resources held by ABBREV_TABLE. */
15410 abbrev_table_free (struct abbrev_table
*abbrev_table
)
15412 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
15413 xfree (abbrev_table
);
15416 /* Same as abbrev_table_free but as a cleanup.
15417 We pass in a pointer to the pointer to the table so that we can
15418 set the pointer to NULL when we're done. It also simplifies
15419 build_type_psymtabs_1. */
15422 abbrev_table_free_cleanup (void *table_ptr
)
15424 struct abbrev_table
**abbrev_table_ptr
= table_ptr
;
15426 if (*abbrev_table_ptr
!= NULL
)
15427 abbrev_table_free (*abbrev_table_ptr
);
15428 *abbrev_table_ptr
= NULL
;
15431 /* Read the abbrev table for CU from ABBREV_SECTION. */
15434 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
15435 struct dwarf2_section_info
*abbrev_section
)
15438 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
15441 /* Release the memory used by the abbrev table for a compilation unit. */
15444 dwarf2_free_abbrev_table (void *ptr_to_cu
)
15446 struct dwarf2_cu
*cu
= ptr_to_cu
;
15448 if (cu
->abbrev_table
!= NULL
)
15449 abbrev_table_free (cu
->abbrev_table
);
15450 /* Set this to NULL so that we SEGV if we try to read it later,
15451 and also because free_comp_unit verifies this is NULL. */
15452 cu
->abbrev_table
= NULL
;
15455 /* Returns nonzero if TAG represents a type that we might generate a partial
15459 is_type_tag_for_partial (int tag
)
15464 /* Some types that would be reasonable to generate partial symbols for,
15465 that we don't at present. */
15466 case DW_TAG_array_type
:
15467 case DW_TAG_file_type
:
15468 case DW_TAG_ptr_to_member_type
:
15469 case DW_TAG_set_type
:
15470 case DW_TAG_string_type
:
15471 case DW_TAG_subroutine_type
:
15473 case DW_TAG_base_type
:
15474 case DW_TAG_class_type
:
15475 case DW_TAG_interface_type
:
15476 case DW_TAG_enumeration_type
:
15477 case DW_TAG_structure_type
:
15478 case DW_TAG_subrange_type
:
15479 case DW_TAG_typedef
:
15480 case DW_TAG_union_type
:
15487 /* Load all DIEs that are interesting for partial symbols into memory. */
15489 static struct partial_die_info
*
15490 load_partial_dies (const struct die_reader_specs
*reader
,
15491 const gdb_byte
*info_ptr
, int building_psymtab
)
15493 struct dwarf2_cu
*cu
= reader
->cu
;
15494 struct objfile
*objfile
= cu
->objfile
;
15495 struct partial_die_info
*part_die
;
15496 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
15497 struct abbrev_info
*abbrev
;
15498 unsigned int bytes_read
;
15499 unsigned int load_all
= 0;
15500 int nesting_level
= 1;
15505 gdb_assert (cu
->per_cu
!= NULL
);
15506 if (cu
->per_cu
->load_all_dies
)
15510 = htab_create_alloc_ex (cu
->header
.length
/ 12,
15514 &cu
->comp_unit_obstack
,
15515 hashtab_obstack_allocate
,
15516 dummy_obstack_deallocate
);
15518 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15519 sizeof (struct partial_die_info
));
15523 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
15525 /* A NULL abbrev means the end of a series of children. */
15526 if (abbrev
== NULL
)
15528 if (--nesting_level
== 0)
15530 /* PART_DIE was probably the last thing allocated on the
15531 comp_unit_obstack, so we could call obstack_free
15532 here. We don't do that because the waste is small,
15533 and will be cleaned up when we're done with this
15534 compilation unit. This way, we're also more robust
15535 against other users of the comp_unit_obstack. */
15538 info_ptr
+= bytes_read
;
15539 last_die
= parent_die
;
15540 parent_die
= parent_die
->die_parent
;
15544 /* Check for template arguments. We never save these; if
15545 they're seen, we just mark the parent, and go on our way. */
15546 if (parent_die
!= NULL
15547 && cu
->language
== language_cplus
15548 && (abbrev
->tag
== DW_TAG_template_type_param
15549 || abbrev
->tag
== DW_TAG_template_value_param
))
15551 parent_die
->has_template_arguments
= 1;
15555 /* We don't need a partial DIE for the template argument. */
15556 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15561 /* We only recurse into c++ subprograms looking for template arguments.
15562 Skip their other children. */
15564 && cu
->language
== language_cplus
15565 && parent_die
!= NULL
15566 && parent_die
->tag
== DW_TAG_subprogram
)
15568 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15572 /* Check whether this DIE is interesting enough to save. Normally
15573 we would not be interested in members here, but there may be
15574 later variables referencing them via DW_AT_specification (for
15575 static members). */
15577 && !is_type_tag_for_partial (abbrev
->tag
)
15578 && abbrev
->tag
!= DW_TAG_constant
15579 && abbrev
->tag
!= DW_TAG_enumerator
15580 && abbrev
->tag
!= DW_TAG_subprogram
15581 && abbrev
->tag
!= DW_TAG_lexical_block
15582 && abbrev
->tag
!= DW_TAG_variable
15583 && abbrev
->tag
!= DW_TAG_namespace
15584 && abbrev
->tag
!= DW_TAG_module
15585 && abbrev
->tag
!= DW_TAG_member
15586 && abbrev
->tag
!= DW_TAG_imported_unit
15587 && abbrev
->tag
!= DW_TAG_imported_declaration
)
15589 /* Otherwise we skip to the next sibling, if any. */
15590 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15594 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
15597 /* This two-pass algorithm for processing partial symbols has a
15598 high cost in cache pressure. Thus, handle some simple cases
15599 here which cover the majority of C partial symbols. DIEs
15600 which neither have specification tags in them, nor could have
15601 specification tags elsewhere pointing at them, can simply be
15602 processed and discarded.
15604 This segment is also optional; scan_partial_symbols and
15605 add_partial_symbol will handle these DIEs if we chain
15606 them in normally. When compilers which do not emit large
15607 quantities of duplicate debug information are more common,
15608 this code can probably be removed. */
15610 /* Any complete simple types at the top level (pretty much all
15611 of them, for a language without namespaces), can be processed
15613 if (parent_die
== NULL
15614 && part_die
->has_specification
== 0
15615 && part_die
->is_declaration
== 0
15616 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
15617 || part_die
->tag
== DW_TAG_base_type
15618 || part_die
->tag
== DW_TAG_subrange_type
))
15620 if (building_psymtab
&& part_die
->name
!= NULL
)
15621 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15622 VAR_DOMAIN
, LOC_TYPEDEF
,
15623 &objfile
->static_psymbols
,
15624 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15625 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15629 /* The exception for DW_TAG_typedef with has_children above is
15630 a workaround of GCC PR debug/47510. In the case of this complaint
15631 type_name_no_tag_or_error will error on such types later.
15633 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15634 it could not find the child DIEs referenced later, this is checked
15635 above. In correct DWARF DW_TAG_typedef should have no children. */
15637 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
15638 complaint (&symfile_complaints
,
15639 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15640 "- DIE at 0x%x [in module %s]"),
15641 part_die
->offset
.sect_off
, objfile_name (objfile
));
15643 /* If we're at the second level, and we're an enumerator, and
15644 our parent has no specification (meaning possibly lives in a
15645 namespace elsewhere), then we can add the partial symbol now
15646 instead of queueing it. */
15647 if (part_die
->tag
== DW_TAG_enumerator
15648 && parent_die
!= NULL
15649 && parent_die
->die_parent
== NULL
15650 && parent_die
->tag
== DW_TAG_enumeration_type
15651 && parent_die
->has_specification
== 0)
15653 if (part_die
->name
== NULL
)
15654 complaint (&symfile_complaints
,
15655 _("malformed enumerator DIE ignored"));
15656 else if (building_psymtab
)
15657 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15658 VAR_DOMAIN
, LOC_CONST
,
15659 (cu
->language
== language_cplus
15660 || cu
->language
== language_java
)
15661 ? &objfile
->global_psymbols
15662 : &objfile
->static_psymbols
,
15663 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15665 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15669 /* We'll save this DIE so link it in. */
15670 part_die
->die_parent
= parent_die
;
15671 part_die
->die_sibling
= NULL
;
15672 part_die
->die_child
= NULL
;
15674 if (last_die
&& last_die
== parent_die
)
15675 last_die
->die_child
= part_die
;
15677 last_die
->die_sibling
= part_die
;
15679 last_die
= part_die
;
15681 if (first_die
== NULL
)
15682 first_die
= part_die
;
15684 /* Maybe add the DIE to the hash table. Not all DIEs that we
15685 find interesting need to be in the hash table, because we
15686 also have the parent/sibling/child chains; only those that we
15687 might refer to by offset later during partial symbol reading.
15689 For now this means things that might have be the target of a
15690 DW_AT_specification, DW_AT_abstract_origin, or
15691 DW_AT_extension. DW_AT_extension will refer only to
15692 namespaces; DW_AT_abstract_origin refers to functions (and
15693 many things under the function DIE, but we do not recurse
15694 into function DIEs during partial symbol reading) and
15695 possibly variables as well; DW_AT_specification refers to
15696 declarations. Declarations ought to have the DW_AT_declaration
15697 flag. It happens that GCC forgets to put it in sometimes, but
15698 only for functions, not for types.
15700 Adding more things than necessary to the hash table is harmless
15701 except for the performance cost. Adding too few will result in
15702 wasted time in find_partial_die, when we reread the compilation
15703 unit with load_all_dies set. */
15706 || abbrev
->tag
== DW_TAG_constant
15707 || abbrev
->tag
== DW_TAG_subprogram
15708 || abbrev
->tag
== DW_TAG_variable
15709 || abbrev
->tag
== DW_TAG_namespace
15710 || part_die
->is_declaration
)
15714 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
15715 part_die
->offset
.sect_off
, INSERT
);
15719 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15720 sizeof (struct partial_die_info
));
15722 /* For some DIEs we want to follow their children (if any). For C
15723 we have no reason to follow the children of structures; for other
15724 languages we have to, so that we can get at method physnames
15725 to infer fully qualified class names, for DW_AT_specification,
15726 and for C++ template arguments. For C++, we also look one level
15727 inside functions to find template arguments (if the name of the
15728 function does not already contain the template arguments).
15730 For Ada, we need to scan the children of subprograms and lexical
15731 blocks as well because Ada allows the definition of nested
15732 entities that could be interesting for the debugger, such as
15733 nested subprograms for instance. */
15734 if (last_die
->has_children
15736 || last_die
->tag
== DW_TAG_namespace
15737 || last_die
->tag
== DW_TAG_module
15738 || last_die
->tag
== DW_TAG_enumeration_type
15739 || (cu
->language
== language_cplus
15740 && last_die
->tag
== DW_TAG_subprogram
15741 && (last_die
->name
== NULL
15742 || strchr (last_die
->name
, '<') == NULL
))
15743 || (cu
->language
!= language_c
15744 && (last_die
->tag
== DW_TAG_class_type
15745 || last_die
->tag
== DW_TAG_interface_type
15746 || last_die
->tag
== DW_TAG_structure_type
15747 || last_die
->tag
== DW_TAG_union_type
))
15748 || (cu
->language
== language_ada
15749 && (last_die
->tag
== DW_TAG_subprogram
15750 || last_die
->tag
== DW_TAG_lexical_block
))))
15753 parent_die
= last_die
;
15757 /* Otherwise we skip to the next sibling, if any. */
15758 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
15760 /* Back to the top, do it again. */
15764 /* Read a minimal amount of information into the minimal die structure. */
15766 static const gdb_byte
*
15767 read_partial_die (const struct die_reader_specs
*reader
,
15768 struct partial_die_info
*part_die
,
15769 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
15770 const gdb_byte
*info_ptr
)
15772 struct dwarf2_cu
*cu
= reader
->cu
;
15773 struct objfile
*objfile
= cu
->objfile
;
15774 const gdb_byte
*buffer
= reader
->buffer
;
15776 struct attribute attr
;
15777 int has_low_pc_attr
= 0;
15778 int has_high_pc_attr
= 0;
15779 int high_pc_relative
= 0;
15781 memset (part_die
, 0, sizeof (struct partial_die_info
));
15783 part_die
->offset
.sect_off
= info_ptr
- buffer
;
15785 info_ptr
+= abbrev_len
;
15787 if (abbrev
== NULL
)
15790 part_die
->tag
= abbrev
->tag
;
15791 part_die
->has_children
= abbrev
->has_children
;
15793 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15795 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
15797 /* Store the data if it is of an attribute we want to keep in a
15798 partial symbol table. */
15802 switch (part_die
->tag
)
15804 case DW_TAG_compile_unit
:
15805 case DW_TAG_partial_unit
:
15806 case DW_TAG_type_unit
:
15807 /* Compilation units have a DW_AT_name that is a filename, not
15808 a source language identifier. */
15809 case DW_TAG_enumeration_type
:
15810 case DW_TAG_enumerator
:
15811 /* These tags always have simple identifiers already; no need
15812 to canonicalize them. */
15813 part_die
->name
= DW_STRING (&attr
);
15817 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
15818 &objfile
->per_bfd
->storage_obstack
);
15822 case DW_AT_linkage_name
:
15823 case DW_AT_MIPS_linkage_name
:
15824 /* Note that both forms of linkage name might appear. We
15825 assume they will be the same, and we only store the last
15827 if (cu
->language
== language_ada
)
15828 part_die
->name
= DW_STRING (&attr
);
15829 part_die
->linkage_name
= DW_STRING (&attr
);
15832 has_low_pc_attr
= 1;
15833 part_die
->lowpc
= attr_value_as_address (&attr
);
15835 case DW_AT_high_pc
:
15836 has_high_pc_attr
= 1;
15837 part_die
->highpc
= attr_value_as_address (&attr
);
15838 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
15839 high_pc_relative
= 1;
15841 case DW_AT_location
:
15842 /* Support the .debug_loc offsets. */
15843 if (attr_form_is_block (&attr
))
15845 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
15847 else if (attr_form_is_section_offset (&attr
))
15849 dwarf2_complex_location_expr_complaint ();
15853 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15854 "partial symbol information");
15857 case DW_AT_external
:
15858 part_die
->is_external
= DW_UNSND (&attr
);
15860 case DW_AT_declaration
:
15861 part_die
->is_declaration
= DW_UNSND (&attr
);
15864 part_die
->has_type
= 1;
15866 case DW_AT_abstract_origin
:
15867 case DW_AT_specification
:
15868 case DW_AT_extension
:
15869 part_die
->has_specification
= 1;
15870 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
15871 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15872 || cu
->per_cu
->is_dwz
);
15874 case DW_AT_sibling
:
15875 /* Ignore absolute siblings, they might point outside of
15876 the current compile unit. */
15877 if (attr
.form
== DW_FORM_ref_addr
)
15878 complaint (&symfile_complaints
,
15879 _("ignoring absolute DW_AT_sibling"));
15882 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
15883 const gdb_byte
*sibling_ptr
= buffer
+ off
;
15885 if (sibling_ptr
< info_ptr
)
15886 complaint (&symfile_complaints
,
15887 _("DW_AT_sibling points backwards"));
15888 else if (sibling_ptr
> reader
->buffer_end
)
15889 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
15891 part_die
->sibling
= sibling_ptr
;
15894 case DW_AT_byte_size
:
15895 part_die
->has_byte_size
= 1;
15897 case DW_AT_const_value
:
15898 part_die
->has_const_value
= 1;
15900 case DW_AT_calling_convention
:
15901 /* DWARF doesn't provide a way to identify a program's source-level
15902 entry point. DW_AT_calling_convention attributes are only meant
15903 to describe functions' calling conventions.
15905 However, because it's a necessary piece of information in
15906 Fortran, and because DW_CC_program is the only piece of debugging
15907 information whose definition refers to a 'main program' at all,
15908 several compilers have begun marking Fortran main programs with
15909 DW_CC_program --- even when those functions use the standard
15910 calling conventions.
15912 So until DWARF specifies a way to provide this information and
15913 compilers pick up the new representation, we'll support this
15915 if (DW_UNSND (&attr
) == DW_CC_program
15916 && cu
->language
== language_fortran
)
15917 set_objfile_main_name (objfile
, part_die
->name
, language_fortran
);
15920 if (DW_UNSND (&attr
) == DW_INL_inlined
15921 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
15922 part_die
->may_be_inlined
= 1;
15926 if (part_die
->tag
== DW_TAG_imported_unit
)
15928 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
15929 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15930 || cu
->per_cu
->is_dwz
);
15939 if (high_pc_relative
)
15940 part_die
->highpc
+= part_die
->lowpc
;
15942 if (has_low_pc_attr
&& has_high_pc_attr
)
15944 /* When using the GNU linker, .gnu.linkonce. sections are used to
15945 eliminate duplicate copies of functions and vtables and such.
15946 The linker will arbitrarily choose one and discard the others.
15947 The AT_*_pc values for such functions refer to local labels in
15948 these sections. If the section from that file was discarded, the
15949 labels are not in the output, so the relocs get a value of 0.
15950 If this is a discarded function, mark the pc bounds as invalid,
15951 so that GDB will ignore it. */
15952 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
15954 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15956 complaint (&symfile_complaints
,
15957 _("DW_AT_low_pc %s is zero "
15958 "for DIE at 0x%x [in module %s]"),
15959 paddress (gdbarch
, part_die
->lowpc
),
15960 part_die
->offset
.sect_off
, objfile_name (objfile
));
15962 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15963 else if (part_die
->lowpc
>= part_die
->highpc
)
15965 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15967 complaint (&symfile_complaints
,
15968 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15969 "for DIE at 0x%x [in module %s]"),
15970 paddress (gdbarch
, part_die
->lowpc
),
15971 paddress (gdbarch
, part_die
->highpc
),
15972 part_die
->offset
.sect_off
, objfile_name (objfile
));
15975 part_die
->has_pc_info
= 1;
15981 /* Find a cached partial DIE at OFFSET in CU. */
15983 static struct partial_die_info
*
15984 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
15986 struct partial_die_info
*lookup_die
= NULL
;
15987 struct partial_die_info part_die
;
15989 part_die
.offset
= offset
;
15990 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
15996 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15997 except in the case of .debug_types DIEs which do not reference
15998 outside their CU (they do however referencing other types via
15999 DW_FORM_ref_sig8). */
16001 static struct partial_die_info
*
16002 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
16004 struct objfile
*objfile
= cu
->objfile
;
16005 struct dwarf2_per_cu_data
*per_cu
= NULL
;
16006 struct partial_die_info
*pd
= NULL
;
16008 if (offset_in_dwz
== cu
->per_cu
->is_dwz
16009 && offset_in_cu_p (&cu
->header
, offset
))
16011 pd
= find_partial_die_in_comp_unit (offset
, cu
);
16014 /* We missed recording what we needed.
16015 Load all dies and try again. */
16016 per_cu
= cu
->per_cu
;
16020 /* TUs don't reference other CUs/TUs (except via type signatures). */
16021 if (cu
->per_cu
->is_debug_types
)
16023 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
16024 " external reference to offset 0x%lx [in module %s].\n"),
16025 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
16026 bfd_get_filename (objfile
->obfd
));
16028 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
16031 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
16032 load_partial_comp_unit (per_cu
);
16034 per_cu
->cu
->last_used
= 0;
16035 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16038 /* If we didn't find it, and not all dies have been loaded,
16039 load them all and try again. */
16041 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
16043 per_cu
->load_all_dies
= 1;
16045 /* This is nasty. When we reread the DIEs, somewhere up the call chain
16046 THIS_CU->cu may already be in use. So we can't just free it and
16047 replace its DIEs with the ones we read in. Instead, we leave those
16048 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
16049 and clobber THIS_CU->cu->partial_dies with the hash table for the new
16051 load_partial_comp_unit (per_cu
);
16053 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16057 internal_error (__FILE__
, __LINE__
,
16058 _("could not find partial DIE 0x%x "
16059 "in cache [from module %s]\n"),
16060 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
16064 /* See if we can figure out if the class lives in a namespace. We do
16065 this by looking for a member function; its demangled name will
16066 contain namespace info, if there is any. */
16069 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
16070 struct dwarf2_cu
*cu
)
16072 /* NOTE: carlton/2003-10-07: Getting the info this way changes
16073 what template types look like, because the demangler
16074 frequently doesn't give the same name as the debug info. We
16075 could fix this by only using the demangled name to get the
16076 prefix (but see comment in read_structure_type). */
16078 struct partial_die_info
*real_pdi
;
16079 struct partial_die_info
*child_pdi
;
16081 /* If this DIE (this DIE's specification, if any) has a parent, then
16082 we should not do this. We'll prepend the parent's fully qualified
16083 name when we create the partial symbol. */
16085 real_pdi
= struct_pdi
;
16086 while (real_pdi
->has_specification
)
16087 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
16088 real_pdi
->spec_is_dwz
, cu
);
16090 if (real_pdi
->die_parent
!= NULL
)
16093 for (child_pdi
= struct_pdi
->die_child
;
16095 child_pdi
= child_pdi
->die_sibling
)
16097 if (child_pdi
->tag
== DW_TAG_subprogram
16098 && child_pdi
->linkage_name
!= NULL
)
16100 char *actual_class_name
16101 = language_class_name_from_physname (cu
->language_defn
,
16102 child_pdi
->linkage_name
);
16103 if (actual_class_name
!= NULL
)
16106 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16108 strlen (actual_class_name
));
16109 xfree (actual_class_name
);
16116 /* Adjust PART_DIE before generating a symbol for it. This function
16117 may set the is_external flag or change the DIE's name. */
16120 fixup_partial_die (struct partial_die_info
*part_die
,
16121 struct dwarf2_cu
*cu
)
16123 /* Once we've fixed up a die, there's no point in doing so again.
16124 This also avoids a memory leak if we were to call
16125 guess_partial_die_structure_name multiple times. */
16126 if (part_die
->fixup_called
)
16129 /* If we found a reference attribute and the DIE has no name, try
16130 to find a name in the referred to DIE. */
16132 if (part_die
->name
== NULL
&& part_die
->has_specification
)
16134 struct partial_die_info
*spec_die
;
16136 spec_die
= find_partial_die (part_die
->spec_offset
,
16137 part_die
->spec_is_dwz
, cu
);
16139 fixup_partial_die (spec_die
, cu
);
16141 if (spec_die
->name
)
16143 part_die
->name
= spec_die
->name
;
16145 /* Copy DW_AT_external attribute if it is set. */
16146 if (spec_die
->is_external
)
16147 part_die
->is_external
= spec_die
->is_external
;
16151 /* Set default names for some unnamed DIEs. */
16153 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
16154 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
16156 /* If there is no parent die to provide a namespace, and there are
16157 children, see if we can determine the namespace from their linkage
16159 if (cu
->language
== language_cplus
16160 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
16161 && part_die
->die_parent
== NULL
16162 && part_die
->has_children
16163 && (part_die
->tag
== DW_TAG_class_type
16164 || part_die
->tag
== DW_TAG_structure_type
16165 || part_die
->tag
== DW_TAG_union_type
))
16166 guess_partial_die_structure_name (part_die
, cu
);
16168 /* GCC might emit a nameless struct or union that has a linkage
16169 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16170 if (part_die
->name
== NULL
16171 && (part_die
->tag
== DW_TAG_class_type
16172 || part_die
->tag
== DW_TAG_interface_type
16173 || part_die
->tag
== DW_TAG_structure_type
16174 || part_die
->tag
== DW_TAG_union_type
)
16175 && part_die
->linkage_name
!= NULL
)
16179 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
16184 /* Strip any leading namespaces/classes, keep only the base name.
16185 DW_AT_name for named DIEs does not contain the prefixes. */
16186 base
= strrchr (demangled
, ':');
16187 if (base
&& base
> demangled
&& base
[-1] == ':')
16193 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16194 base
, strlen (base
));
16199 part_die
->fixup_called
= 1;
16202 /* Read an attribute value described by an attribute form. */
16204 static const gdb_byte
*
16205 read_attribute_value (const struct die_reader_specs
*reader
,
16206 struct attribute
*attr
, unsigned form
,
16207 const gdb_byte
*info_ptr
)
16209 struct dwarf2_cu
*cu
= reader
->cu
;
16210 struct objfile
*objfile
= cu
->objfile
;
16211 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16212 bfd
*abfd
= reader
->abfd
;
16213 struct comp_unit_head
*cu_header
= &cu
->header
;
16214 unsigned int bytes_read
;
16215 struct dwarf_block
*blk
;
16217 attr
->form
= (enum dwarf_form
) form
;
16220 case DW_FORM_ref_addr
:
16221 if (cu
->header
.version
== 2)
16222 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16224 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
16225 &cu
->header
, &bytes_read
);
16226 info_ptr
+= bytes_read
;
16228 case DW_FORM_GNU_ref_alt
:
16229 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16230 info_ptr
+= bytes_read
;
16233 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16234 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
16235 info_ptr
+= bytes_read
;
16237 case DW_FORM_block2
:
16238 blk
= dwarf_alloc_block (cu
);
16239 blk
->size
= read_2_bytes (abfd
, info_ptr
);
16241 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16242 info_ptr
+= blk
->size
;
16243 DW_BLOCK (attr
) = blk
;
16245 case DW_FORM_block4
:
16246 blk
= dwarf_alloc_block (cu
);
16247 blk
->size
= read_4_bytes (abfd
, info_ptr
);
16249 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16250 info_ptr
+= blk
->size
;
16251 DW_BLOCK (attr
) = blk
;
16253 case DW_FORM_data2
:
16254 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
16257 case DW_FORM_data4
:
16258 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
16261 case DW_FORM_data8
:
16262 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
16265 case DW_FORM_sec_offset
:
16266 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16267 info_ptr
+= bytes_read
;
16269 case DW_FORM_string
:
16270 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
16271 DW_STRING_IS_CANONICAL (attr
) = 0;
16272 info_ptr
+= bytes_read
;
16275 if (!cu
->per_cu
->is_dwz
)
16277 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
16279 DW_STRING_IS_CANONICAL (attr
) = 0;
16280 info_ptr
+= bytes_read
;
16284 case DW_FORM_GNU_strp_alt
:
16286 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
16287 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
16290 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
16291 DW_STRING_IS_CANONICAL (attr
) = 0;
16292 info_ptr
+= bytes_read
;
16295 case DW_FORM_exprloc
:
16296 case DW_FORM_block
:
16297 blk
= dwarf_alloc_block (cu
);
16298 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16299 info_ptr
+= bytes_read
;
16300 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16301 info_ptr
+= blk
->size
;
16302 DW_BLOCK (attr
) = blk
;
16304 case DW_FORM_block1
:
16305 blk
= dwarf_alloc_block (cu
);
16306 blk
->size
= read_1_byte (abfd
, info_ptr
);
16308 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16309 info_ptr
+= blk
->size
;
16310 DW_BLOCK (attr
) = blk
;
16312 case DW_FORM_data1
:
16313 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16317 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16320 case DW_FORM_flag_present
:
16321 DW_UNSND (attr
) = 1;
16323 case DW_FORM_sdata
:
16324 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
16325 info_ptr
+= bytes_read
;
16327 case DW_FORM_udata
:
16328 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16329 info_ptr
+= bytes_read
;
16332 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16333 + read_1_byte (abfd
, info_ptr
));
16337 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16338 + read_2_bytes (abfd
, info_ptr
));
16342 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16343 + read_4_bytes (abfd
, info_ptr
));
16347 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16348 + read_8_bytes (abfd
, info_ptr
));
16351 case DW_FORM_ref_sig8
:
16352 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
16355 case DW_FORM_ref_udata
:
16356 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16357 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
16358 info_ptr
+= bytes_read
;
16360 case DW_FORM_indirect
:
16361 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16362 info_ptr
+= bytes_read
;
16363 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
16365 case DW_FORM_GNU_addr_index
:
16366 if (reader
->dwo_file
== NULL
)
16368 /* For now flag a hard error.
16369 Later we can turn this into a complaint. */
16370 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16371 dwarf_form_name (form
),
16372 bfd_get_filename (abfd
));
16374 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
16375 info_ptr
+= bytes_read
;
16377 case DW_FORM_GNU_str_index
:
16378 if (reader
->dwo_file
== NULL
)
16380 /* For now flag a hard error.
16381 Later we can turn this into a complaint if warranted. */
16382 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16383 dwarf_form_name (form
),
16384 bfd_get_filename (abfd
));
16387 ULONGEST str_index
=
16388 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16390 DW_STRING (attr
) = read_str_index (reader
, str_index
);
16391 DW_STRING_IS_CANONICAL (attr
) = 0;
16392 info_ptr
+= bytes_read
;
16396 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16397 dwarf_form_name (form
),
16398 bfd_get_filename (abfd
));
16402 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
16403 attr
->form
= DW_FORM_GNU_ref_alt
;
16405 /* We have seen instances where the compiler tried to emit a byte
16406 size attribute of -1 which ended up being encoded as an unsigned
16407 0xffffffff. Although 0xffffffff is technically a valid size value,
16408 an object of this size seems pretty unlikely so we can relatively
16409 safely treat these cases as if the size attribute was invalid and
16410 treat them as zero by default. */
16411 if (attr
->name
== DW_AT_byte_size
16412 && form
== DW_FORM_data4
16413 && DW_UNSND (attr
) >= 0xffffffff)
16416 (&symfile_complaints
,
16417 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16418 hex_string (DW_UNSND (attr
)));
16419 DW_UNSND (attr
) = 0;
16425 /* Read an attribute described by an abbreviated attribute. */
16427 static const gdb_byte
*
16428 read_attribute (const struct die_reader_specs
*reader
,
16429 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
16430 const gdb_byte
*info_ptr
)
16432 attr
->name
= abbrev
->name
;
16433 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
16436 /* Read dwarf information from a buffer. */
16438 static unsigned int
16439 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
16441 return bfd_get_8 (abfd
, buf
);
16445 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
16447 return bfd_get_signed_8 (abfd
, buf
);
16450 static unsigned int
16451 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16453 return bfd_get_16 (abfd
, buf
);
16457 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16459 return bfd_get_signed_16 (abfd
, buf
);
16462 static unsigned int
16463 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16465 return bfd_get_32 (abfd
, buf
);
16469 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16471 return bfd_get_signed_32 (abfd
, buf
);
16475 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16477 return bfd_get_64 (abfd
, buf
);
16481 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
16482 unsigned int *bytes_read
)
16484 struct comp_unit_head
*cu_header
= &cu
->header
;
16485 CORE_ADDR retval
= 0;
16487 if (cu_header
->signed_addr_p
)
16489 switch (cu_header
->addr_size
)
16492 retval
= bfd_get_signed_16 (abfd
, buf
);
16495 retval
= bfd_get_signed_32 (abfd
, buf
);
16498 retval
= bfd_get_signed_64 (abfd
, buf
);
16501 internal_error (__FILE__
, __LINE__
,
16502 _("read_address: bad switch, signed [in module %s]"),
16503 bfd_get_filename (abfd
));
16508 switch (cu_header
->addr_size
)
16511 retval
= bfd_get_16 (abfd
, buf
);
16514 retval
= bfd_get_32 (abfd
, buf
);
16517 retval
= bfd_get_64 (abfd
, buf
);
16520 internal_error (__FILE__
, __LINE__
,
16521 _("read_address: bad switch, "
16522 "unsigned [in module %s]"),
16523 bfd_get_filename (abfd
));
16527 *bytes_read
= cu_header
->addr_size
;
16531 /* Read the initial length from a section. The (draft) DWARF 3
16532 specification allows the initial length to take up either 4 bytes
16533 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16534 bytes describe the length and all offsets will be 8 bytes in length
16537 An older, non-standard 64-bit format is also handled by this
16538 function. The older format in question stores the initial length
16539 as an 8-byte quantity without an escape value. Lengths greater
16540 than 2^32 aren't very common which means that the initial 4 bytes
16541 is almost always zero. Since a length value of zero doesn't make
16542 sense for the 32-bit format, this initial zero can be considered to
16543 be an escape value which indicates the presence of the older 64-bit
16544 format. As written, the code can't detect (old format) lengths
16545 greater than 4GB. If it becomes necessary to handle lengths
16546 somewhat larger than 4GB, we could allow other small values (such
16547 as the non-sensical values of 1, 2, and 3) to also be used as
16548 escape values indicating the presence of the old format.
16550 The value returned via bytes_read should be used to increment the
16551 relevant pointer after calling read_initial_length().
16553 [ Note: read_initial_length() and read_offset() are based on the
16554 document entitled "DWARF Debugging Information Format", revision
16555 3, draft 8, dated November 19, 2001. This document was obtained
16558 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16560 This document is only a draft and is subject to change. (So beware.)
16562 Details regarding the older, non-standard 64-bit format were
16563 determined empirically by examining 64-bit ELF files produced by
16564 the SGI toolchain on an IRIX 6.5 machine.
16566 - Kevin, July 16, 2002
16570 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
16572 LONGEST length
= bfd_get_32 (abfd
, buf
);
16574 if (length
== 0xffffffff)
16576 length
= bfd_get_64 (abfd
, buf
+ 4);
16579 else if (length
== 0)
16581 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16582 length
= bfd_get_64 (abfd
, buf
);
16593 /* Cover function for read_initial_length.
16594 Returns the length of the object at BUF, and stores the size of the
16595 initial length in *BYTES_READ and stores the size that offsets will be in
16597 If the initial length size is not equivalent to that specified in
16598 CU_HEADER then issue a complaint.
16599 This is useful when reading non-comp-unit headers. */
16602 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
16603 const struct comp_unit_head
*cu_header
,
16604 unsigned int *bytes_read
,
16605 unsigned int *offset_size
)
16607 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
16609 gdb_assert (cu_header
->initial_length_size
== 4
16610 || cu_header
->initial_length_size
== 8
16611 || cu_header
->initial_length_size
== 12);
16613 if (cu_header
->initial_length_size
!= *bytes_read
)
16614 complaint (&symfile_complaints
,
16615 _("intermixed 32-bit and 64-bit DWARF sections"));
16617 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
16621 /* Read an offset from the data stream. The size of the offset is
16622 given by cu_header->offset_size. */
16625 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
16626 const struct comp_unit_head
*cu_header
,
16627 unsigned int *bytes_read
)
16629 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
16631 *bytes_read
= cu_header
->offset_size
;
16635 /* Read an offset from the data stream. */
16638 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
16640 LONGEST retval
= 0;
16642 switch (offset_size
)
16645 retval
= bfd_get_32 (abfd
, buf
);
16648 retval
= bfd_get_64 (abfd
, buf
);
16651 internal_error (__FILE__
, __LINE__
,
16652 _("read_offset_1: bad switch [in module %s]"),
16653 bfd_get_filename (abfd
));
16659 static const gdb_byte
*
16660 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
16662 /* If the size of a host char is 8 bits, we can return a pointer
16663 to the buffer, otherwise we have to copy the data to a buffer
16664 allocated on the temporary obstack. */
16665 gdb_assert (HOST_CHAR_BIT
== 8);
16669 static const char *
16670 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
16671 unsigned int *bytes_read_ptr
)
16673 /* If the size of a host char is 8 bits, we can return a pointer
16674 to the string, otherwise we have to copy the string to a buffer
16675 allocated on the temporary obstack. */
16676 gdb_assert (HOST_CHAR_BIT
== 8);
16679 *bytes_read_ptr
= 1;
16682 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
16683 return (const char *) buf
;
16686 static const char *
16687 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
16689 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
16690 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
16691 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16692 bfd_get_filename (abfd
));
16693 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
16694 error (_("DW_FORM_strp pointing outside of "
16695 ".debug_str section [in module %s]"),
16696 bfd_get_filename (abfd
));
16697 gdb_assert (HOST_CHAR_BIT
== 8);
16698 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
16700 return (const char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
16703 /* Read a string at offset STR_OFFSET in the .debug_str section from
16704 the .dwz file DWZ. Throw an error if the offset is too large. If
16705 the string consists of a single NUL byte, return NULL; otherwise
16706 return a pointer to the string. */
16708 static const char *
16709 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
16711 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
16713 if (dwz
->str
.buffer
== NULL
)
16714 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16715 "section [in module %s]"),
16716 bfd_get_filename (dwz
->dwz_bfd
));
16717 if (str_offset
>= dwz
->str
.size
)
16718 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16719 ".debug_str section [in module %s]"),
16720 bfd_get_filename (dwz
->dwz_bfd
));
16721 gdb_assert (HOST_CHAR_BIT
== 8);
16722 if (dwz
->str
.buffer
[str_offset
] == '\0')
16724 return (const char *) (dwz
->str
.buffer
+ str_offset
);
16727 static const char *
16728 read_indirect_string (bfd
*abfd
, const gdb_byte
*buf
,
16729 const struct comp_unit_head
*cu_header
,
16730 unsigned int *bytes_read_ptr
)
16732 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
16734 return read_indirect_string_at_offset (abfd
, str_offset
);
16738 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16739 unsigned int *bytes_read_ptr
)
16742 unsigned int num_read
;
16744 unsigned char byte
;
16752 byte
= bfd_get_8 (abfd
, buf
);
16755 result
|= ((ULONGEST
) (byte
& 127) << shift
);
16756 if ((byte
& 128) == 0)
16762 *bytes_read_ptr
= num_read
;
16767 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16768 unsigned int *bytes_read_ptr
)
16771 int i
, shift
, num_read
;
16772 unsigned char byte
;
16780 byte
= bfd_get_8 (abfd
, buf
);
16783 result
|= ((LONGEST
) (byte
& 127) << shift
);
16785 if ((byte
& 128) == 0)
16790 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
16791 result
|= -(((LONGEST
) 1) << shift
);
16792 *bytes_read_ptr
= num_read
;
16796 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16797 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16798 ADDR_SIZE is the size of addresses from the CU header. */
16801 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
16803 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16804 bfd
*abfd
= objfile
->obfd
;
16805 const gdb_byte
*info_ptr
;
16807 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
16808 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
16809 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16810 objfile_name (objfile
));
16811 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
16812 error (_("DW_FORM_addr_index pointing outside of "
16813 ".debug_addr section [in module %s]"),
16814 objfile_name (objfile
));
16815 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
16816 + addr_base
+ addr_index
* addr_size
);
16817 if (addr_size
== 4)
16818 return bfd_get_32 (abfd
, info_ptr
);
16820 return bfd_get_64 (abfd
, info_ptr
);
16823 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16826 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
16828 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
16831 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16834 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
16835 unsigned int *bytes_read
)
16837 bfd
*abfd
= cu
->objfile
->obfd
;
16838 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
16840 return read_addr_index (cu
, addr_index
);
16843 /* Data structure to pass results from dwarf2_read_addr_index_reader
16844 back to dwarf2_read_addr_index. */
16846 struct dwarf2_read_addr_index_data
16848 ULONGEST addr_base
;
16852 /* die_reader_func for dwarf2_read_addr_index. */
16855 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
16856 const gdb_byte
*info_ptr
,
16857 struct die_info
*comp_unit_die
,
16861 struct dwarf2_cu
*cu
= reader
->cu
;
16862 struct dwarf2_read_addr_index_data
*aidata
=
16863 (struct dwarf2_read_addr_index_data
*) data
;
16865 aidata
->addr_base
= cu
->addr_base
;
16866 aidata
->addr_size
= cu
->header
.addr_size
;
16869 /* Given an index in .debug_addr, fetch the value.
16870 NOTE: This can be called during dwarf expression evaluation,
16871 long after the debug information has been read, and thus per_cu->cu
16872 may no longer exist. */
16875 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
16876 unsigned int addr_index
)
16878 struct objfile
*objfile
= per_cu
->objfile
;
16879 struct dwarf2_cu
*cu
= per_cu
->cu
;
16880 ULONGEST addr_base
;
16883 /* This is intended to be called from outside this file. */
16884 dw2_setup (objfile
);
16886 /* We need addr_base and addr_size.
16887 If we don't have PER_CU->cu, we have to get it.
16888 Nasty, but the alternative is storing the needed info in PER_CU,
16889 which at this point doesn't seem justified: it's not clear how frequently
16890 it would get used and it would increase the size of every PER_CU.
16891 Entry points like dwarf2_per_cu_addr_size do a similar thing
16892 so we're not in uncharted territory here.
16893 Alas we need to be a bit more complicated as addr_base is contained
16896 We don't need to read the entire CU(/TU).
16897 We just need the header and top level die.
16899 IWBN to use the aging mechanism to let us lazily later discard the CU.
16900 For now we skip this optimization. */
16904 addr_base
= cu
->addr_base
;
16905 addr_size
= cu
->header
.addr_size
;
16909 struct dwarf2_read_addr_index_data aidata
;
16911 /* Note: We can't use init_cutu_and_read_dies_simple here,
16912 we need addr_base. */
16913 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
16914 dwarf2_read_addr_index_reader
, &aidata
);
16915 addr_base
= aidata
.addr_base
;
16916 addr_size
= aidata
.addr_size
;
16919 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
16922 /* Given a DW_FORM_GNU_str_index, fetch the string.
16923 This is only used by the Fission support. */
16925 static const char *
16926 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
16928 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16929 const char *objf_name
= objfile_name (objfile
);
16930 bfd
*abfd
= objfile
->obfd
;
16931 struct dwarf2_cu
*cu
= reader
->cu
;
16932 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
16933 struct dwarf2_section_info
*str_offsets_section
=
16934 &reader
->dwo_file
->sections
.str_offsets
;
16935 const gdb_byte
*info_ptr
;
16936 ULONGEST str_offset
;
16937 static const char form_name
[] = "DW_FORM_GNU_str_index";
16939 dwarf2_read_section (objfile
, str_section
);
16940 dwarf2_read_section (objfile
, str_offsets_section
);
16941 if (str_section
->buffer
== NULL
)
16942 error (_("%s used without .debug_str.dwo section"
16943 " in CU at offset 0x%lx [in module %s]"),
16944 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16945 if (str_offsets_section
->buffer
== NULL
)
16946 error (_("%s used without .debug_str_offsets.dwo section"
16947 " in CU at offset 0x%lx [in module %s]"),
16948 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16949 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
16950 error (_("%s pointing outside of .debug_str_offsets.dwo"
16951 " section in CU at offset 0x%lx [in module %s]"),
16952 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16953 info_ptr
= (str_offsets_section
->buffer
16954 + str_index
* cu
->header
.offset_size
);
16955 if (cu
->header
.offset_size
== 4)
16956 str_offset
= bfd_get_32 (abfd
, info_ptr
);
16958 str_offset
= bfd_get_64 (abfd
, info_ptr
);
16959 if (str_offset
>= str_section
->size
)
16960 error (_("Offset from %s pointing outside of"
16961 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16962 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16963 return (const char *) (str_section
->buffer
+ str_offset
);
16966 /* Return the length of an LEB128 number in BUF. */
16969 leb128_size (const gdb_byte
*buf
)
16971 const gdb_byte
*begin
= buf
;
16977 if ((byte
& 128) == 0)
16978 return buf
- begin
;
16983 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
16992 cu
->language
= language_c
;
16994 case DW_LANG_C_plus_plus
:
16995 case DW_LANG_C_plus_plus_11
:
16996 case DW_LANG_C_plus_plus_14
:
16997 cu
->language
= language_cplus
;
17000 cu
->language
= language_d
;
17002 case DW_LANG_Fortran77
:
17003 case DW_LANG_Fortran90
:
17004 case DW_LANG_Fortran95
:
17005 case DW_LANG_Fortran03
:
17006 case DW_LANG_Fortran08
:
17007 cu
->language
= language_fortran
;
17010 cu
->language
= language_go
;
17012 case DW_LANG_Mips_Assembler
:
17013 cu
->language
= language_asm
;
17016 cu
->language
= language_java
;
17018 case DW_LANG_Ada83
:
17019 case DW_LANG_Ada95
:
17020 cu
->language
= language_ada
;
17022 case DW_LANG_Modula2
:
17023 cu
->language
= language_m2
;
17025 case DW_LANG_Pascal83
:
17026 cu
->language
= language_pascal
;
17029 cu
->language
= language_objc
;
17031 case DW_LANG_Cobol74
:
17032 case DW_LANG_Cobol85
:
17034 cu
->language
= language_minimal
;
17037 cu
->language_defn
= language_def (cu
->language
);
17040 /* Return the named attribute or NULL if not there. */
17042 static struct attribute
*
17043 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
17048 struct attribute
*spec
= NULL
;
17050 for (i
= 0; i
< die
->num_attrs
; ++i
)
17052 if (die
->attrs
[i
].name
== name
)
17053 return &die
->attrs
[i
];
17054 if (die
->attrs
[i
].name
== DW_AT_specification
17055 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
17056 spec
= &die
->attrs
[i
];
17062 die
= follow_die_ref (die
, spec
, &cu
);
17068 /* Return the named attribute or NULL if not there,
17069 but do not follow DW_AT_specification, etc.
17070 This is for use in contexts where we're reading .debug_types dies.
17071 Following DW_AT_specification, DW_AT_abstract_origin will take us
17072 back up the chain, and we want to go down. */
17074 static struct attribute
*
17075 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
17079 for (i
= 0; i
< die
->num_attrs
; ++i
)
17080 if (die
->attrs
[i
].name
== name
)
17081 return &die
->attrs
[i
];
17086 /* Return non-zero iff the attribute NAME is defined for the given DIE,
17087 and holds a non-zero value. This function should only be used for
17088 DW_FORM_flag or DW_FORM_flag_present attributes. */
17091 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
17093 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
17095 return (attr
&& DW_UNSND (attr
));
17099 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
17101 /* A DIE is a declaration if it has a DW_AT_declaration attribute
17102 which value is non-zero. However, we have to be careful with
17103 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
17104 (via dwarf2_flag_true_p) follows this attribute. So we may
17105 end up accidently finding a declaration attribute that belongs
17106 to a different DIE referenced by the specification attribute,
17107 even though the given DIE does not have a declaration attribute. */
17108 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
17109 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
17112 /* Return the die giving the specification for DIE, if there is
17113 one. *SPEC_CU is the CU containing DIE on input, and the CU
17114 containing the return value on output. If there is no
17115 specification, but there is an abstract origin, that is
17118 static struct die_info
*
17119 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
17121 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
17124 if (spec_attr
== NULL
)
17125 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
17127 if (spec_attr
== NULL
)
17130 return follow_die_ref (die
, spec_attr
, spec_cu
);
17133 /* Free the line_header structure *LH, and any arrays and strings it
17135 NOTE: This is also used as a "cleanup" function. */
17138 free_line_header (struct line_header
*lh
)
17140 if (lh
->standard_opcode_lengths
)
17141 xfree (lh
->standard_opcode_lengths
);
17143 /* Remember that all the lh->file_names[i].name pointers are
17144 pointers into debug_line_buffer, and don't need to be freed. */
17145 if (lh
->file_names
)
17146 xfree (lh
->file_names
);
17148 /* Similarly for the include directory names. */
17149 if (lh
->include_dirs
)
17150 xfree (lh
->include_dirs
);
17155 /* Stub for free_line_header to match void * callback types. */
17158 free_line_header_voidp (void *arg
)
17160 struct line_header
*lh
= arg
;
17162 free_line_header (lh
);
17165 /* Add an entry to LH's include directory table. */
17168 add_include_dir (struct line_header
*lh
, const char *include_dir
)
17170 if (dwarf_line_debug
>= 2)
17171 fprintf_unfiltered (gdb_stdlog
, "Adding dir %u: %s\n",
17172 lh
->num_include_dirs
+ 1, include_dir
);
17174 /* Grow the array if necessary. */
17175 if (lh
->include_dirs_size
== 0)
17177 lh
->include_dirs_size
= 1; /* for testing */
17178 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
17179 * sizeof (*lh
->include_dirs
));
17181 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
17183 lh
->include_dirs_size
*= 2;
17184 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
17185 (lh
->include_dirs_size
17186 * sizeof (*lh
->include_dirs
)));
17189 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
17192 /* Add an entry to LH's file name table. */
17195 add_file_name (struct line_header
*lh
,
17197 unsigned int dir_index
,
17198 unsigned int mod_time
,
17199 unsigned int length
)
17201 struct file_entry
*fe
;
17203 if (dwarf_line_debug
>= 2)
17204 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
17205 lh
->num_file_names
+ 1, name
);
17207 /* Grow the array if necessary. */
17208 if (lh
->file_names_size
== 0)
17210 lh
->file_names_size
= 1; /* for testing */
17211 lh
->file_names
= xmalloc (lh
->file_names_size
17212 * sizeof (*lh
->file_names
));
17214 else if (lh
->num_file_names
>= lh
->file_names_size
)
17216 lh
->file_names_size
*= 2;
17217 lh
->file_names
= xrealloc (lh
->file_names
,
17218 (lh
->file_names_size
17219 * sizeof (*lh
->file_names
)));
17222 fe
= &lh
->file_names
[lh
->num_file_names
++];
17224 fe
->dir_index
= dir_index
;
17225 fe
->mod_time
= mod_time
;
17226 fe
->length
= length
;
17227 fe
->included_p
= 0;
17231 /* A convenience function to find the proper .debug_line section for a CU. */
17233 static struct dwarf2_section_info
*
17234 get_debug_line_section (struct dwarf2_cu
*cu
)
17236 struct dwarf2_section_info
*section
;
17238 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
17240 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17241 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
17242 else if (cu
->per_cu
->is_dwz
)
17244 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17246 section
= &dwz
->line
;
17249 section
= &dwarf2_per_objfile
->line
;
17254 /* Read the statement program header starting at OFFSET in
17255 .debug_line, or .debug_line.dwo. Return a pointer
17256 to a struct line_header, allocated using xmalloc.
17257 Returns NULL if there is a problem reading the header, e.g., if it
17258 has a version we don't understand.
17260 NOTE: the strings in the include directory and file name tables of
17261 the returned object point into the dwarf line section buffer,
17262 and must not be freed. */
17264 static struct line_header
*
17265 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
17267 struct cleanup
*back_to
;
17268 struct line_header
*lh
;
17269 const gdb_byte
*line_ptr
;
17270 unsigned int bytes_read
, offset_size
;
17272 const char *cur_dir
, *cur_file
;
17273 struct dwarf2_section_info
*section
;
17276 section
= get_debug_line_section (cu
);
17277 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
17278 if (section
->buffer
== NULL
)
17280 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17281 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
17283 complaint (&symfile_complaints
, _("missing .debug_line section"));
17287 /* We can't do this until we know the section is non-empty.
17288 Only then do we know we have such a section. */
17289 abfd
= get_section_bfd_owner (section
);
17291 /* Make sure that at least there's room for the total_length field.
17292 That could be 12 bytes long, but we're just going to fudge that. */
17293 if (offset
+ 4 >= section
->size
)
17295 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17299 lh
= xmalloc (sizeof (*lh
));
17300 memset (lh
, 0, sizeof (*lh
));
17301 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
17304 lh
->offset
.sect_off
= offset
;
17305 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
17307 line_ptr
= section
->buffer
+ offset
;
17309 /* Read in the header. */
17311 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
17312 &bytes_read
, &offset_size
);
17313 line_ptr
+= bytes_read
;
17314 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
17316 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17317 do_cleanups (back_to
);
17320 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
17321 lh
->version
= read_2_bytes (abfd
, line_ptr
);
17323 if (lh
->version
> 4)
17325 /* This is a version we don't understand. The format could have
17326 changed in ways we don't handle properly so just punt. */
17327 complaint (&symfile_complaints
,
17328 _("unsupported version in .debug_line section"));
17331 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
17332 line_ptr
+= offset_size
;
17333 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
17335 if (lh
->version
>= 4)
17337 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
17341 lh
->maximum_ops_per_instruction
= 1;
17343 if (lh
->maximum_ops_per_instruction
== 0)
17345 lh
->maximum_ops_per_instruction
= 1;
17346 complaint (&symfile_complaints
,
17347 _("invalid maximum_ops_per_instruction "
17348 "in `.debug_line' section"));
17351 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
17353 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
17355 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
17357 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
17359 lh
->standard_opcode_lengths
17360 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
17362 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
17363 for (i
= 1; i
< lh
->opcode_base
; ++i
)
17365 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
17369 /* Read directory table. */
17370 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17372 line_ptr
+= bytes_read
;
17373 add_include_dir (lh
, cur_dir
);
17375 line_ptr
+= bytes_read
;
17377 /* Read file name table. */
17378 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17380 unsigned int dir_index
, mod_time
, length
;
17382 line_ptr
+= bytes_read
;
17383 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17384 line_ptr
+= bytes_read
;
17385 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17386 line_ptr
+= bytes_read
;
17387 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17388 line_ptr
+= bytes_read
;
17390 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17392 line_ptr
+= bytes_read
;
17393 lh
->statement_program_start
= line_ptr
;
17395 if (line_ptr
> (section
->buffer
+ section
->size
))
17396 complaint (&symfile_complaints
,
17397 _("line number info header doesn't "
17398 "fit in `.debug_line' section"));
17400 discard_cleanups (back_to
);
17404 /* Subroutine of dwarf_decode_lines to simplify it.
17405 Return the file name of the psymtab for included file FILE_INDEX
17406 in line header LH of PST.
17407 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17408 If space for the result is malloc'd, it will be freed by a cleanup.
17409 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17411 The function creates dangling cleanup registration. */
17413 static const char *
17414 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
17415 const struct partial_symtab
*pst
,
17416 const char *comp_dir
)
17418 const struct file_entry fe
= lh
->file_names
[file_index
];
17419 const char *include_name
= fe
.name
;
17420 const char *include_name_to_compare
= include_name
;
17421 const char *dir_name
= NULL
;
17422 const char *pst_filename
;
17423 char *copied_name
= NULL
;
17426 if (fe
.dir_index
&& lh
->include_dirs
!= NULL
)
17427 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
17429 if (!IS_ABSOLUTE_PATH (include_name
)
17430 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
17432 /* Avoid creating a duplicate psymtab for PST.
17433 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17434 Before we do the comparison, however, we need to account
17435 for DIR_NAME and COMP_DIR.
17436 First prepend dir_name (if non-NULL). If we still don't
17437 have an absolute path prepend comp_dir (if non-NULL).
17438 However, the directory we record in the include-file's
17439 psymtab does not contain COMP_DIR (to match the
17440 corresponding symtab(s)).
17445 bash$ gcc -g ./hello.c
17446 include_name = "hello.c"
17448 DW_AT_comp_dir = comp_dir = "/tmp"
17449 DW_AT_name = "./hello.c"
17453 if (dir_name
!= NULL
)
17455 char *tem
= concat (dir_name
, SLASH_STRING
,
17456 include_name
, (char *)NULL
);
17458 make_cleanup (xfree
, tem
);
17459 include_name
= tem
;
17460 include_name_to_compare
= include_name
;
17462 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
17464 char *tem
= concat (comp_dir
, SLASH_STRING
,
17465 include_name
, (char *)NULL
);
17467 make_cleanup (xfree
, tem
);
17468 include_name_to_compare
= tem
;
17472 pst_filename
= pst
->filename
;
17473 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
17475 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
17476 pst_filename
, (char *)NULL
);
17477 pst_filename
= copied_name
;
17480 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
17482 if (copied_name
!= NULL
)
17483 xfree (copied_name
);
17487 return include_name
;
17490 /* State machine to track the state of the line number program. */
17494 /* These are part of the standard DWARF line number state machine. */
17496 unsigned char op_index
;
17501 unsigned int discriminator
;
17503 /* Additional bits of state we need to track. */
17505 /* The last file that we called dwarf2_start_subfile for.
17506 This is only used for TLLs. */
17507 unsigned int last_file
;
17508 /* The last file a line number was recorded for. */
17509 struct subfile
*last_subfile
;
17511 /* The function to call to record a line. */
17512 record_line_ftype
*record_line
;
17514 /* The last line number that was recorded, used to coalesce
17515 consecutive entries for the same line. This can happen, for
17516 example, when discriminators are present. PR 17276. */
17517 unsigned int last_line
;
17518 int line_has_non_zero_discriminator
;
17519 } lnp_state_machine
;
17521 /* There's a lot of static state to pass to dwarf_record_line.
17522 This keeps it all together. */
17527 struct gdbarch
*gdbarch
;
17529 /* The line number header. */
17530 struct line_header
*line_header
;
17532 /* Non-zero if we're recording lines.
17533 Otherwise we're building partial symtabs and are just interested in
17534 finding include files mentioned by the line number program. */
17535 int record_lines_p
;
17536 } lnp_reader_state
;
17538 /* Ignore this record_line request. */
17541 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17546 /* Return non-zero if we should add LINE to the line number table.
17547 LINE is the line to add, LAST_LINE is the last line that was added,
17548 LAST_SUBFILE is the subfile for LAST_LINE.
17549 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17550 had a non-zero discriminator.
17552 We have to be careful in the presence of discriminators.
17553 E.g., for this line:
17555 for (i = 0; i < 100000; i++);
17557 clang can emit four line number entries for that one line,
17558 each with a different discriminator.
17559 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17561 However, we want gdb to coalesce all four entries into one.
17562 Otherwise the user could stepi into the middle of the line and
17563 gdb would get confused about whether the pc really was in the
17564 middle of the line.
17566 Things are further complicated by the fact that two consecutive
17567 line number entries for the same line is a heuristic used by gcc
17568 to denote the end of the prologue. So we can't just discard duplicate
17569 entries, we have to be selective about it. The heuristic we use is
17570 that we only collapse consecutive entries for the same line if at least
17571 one of those entries has a non-zero discriminator. PR 17276.
17573 Note: Addresses in the line number state machine can never go backwards
17574 within one sequence, thus this coalescing is ok. */
17577 dwarf_record_line_p (unsigned int line
, unsigned int last_line
,
17578 int line_has_non_zero_discriminator
,
17579 struct subfile
*last_subfile
)
17581 if (current_subfile
!= last_subfile
)
17583 if (line
!= last_line
)
17585 /* Same line for the same file that we've seen already.
17586 As a last check, for pr 17276, only record the line if the line
17587 has never had a non-zero discriminator. */
17588 if (!line_has_non_zero_discriminator
)
17593 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17594 in the line table of subfile SUBFILE. */
17597 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17598 unsigned int line
, CORE_ADDR address
,
17599 record_line_ftype p_record_line
)
17601 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17603 if (dwarf_line_debug
)
17605 fprintf_unfiltered (gdb_stdlog
,
17606 "Recording line %u, file %s, address %s\n",
17607 line
, lbasename (subfile
->name
),
17608 paddress (gdbarch
, address
));
17611 (*p_record_line
) (subfile
, line
, addr
);
17614 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17615 Mark the end of a set of line number records.
17616 The arguments are the same as for dwarf_record_line_1.
17617 If SUBFILE is NULL the request is ignored. */
17620 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17621 CORE_ADDR address
, record_line_ftype p_record_line
)
17623 if (subfile
== NULL
)
17626 if (dwarf_line_debug
)
17628 fprintf_unfiltered (gdb_stdlog
,
17629 "Finishing current line, file %s, address %s\n",
17630 lbasename (subfile
->name
),
17631 paddress (gdbarch
, address
));
17634 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, p_record_line
);
17637 /* Record the line in STATE.
17638 END_SEQUENCE is non-zero if we're processing the end of a sequence. */
17641 dwarf_record_line (lnp_reader_state
*reader
, lnp_state_machine
*state
,
17644 const struct line_header
*lh
= reader
->line_header
;
17645 unsigned int file
, line
, discriminator
;
17648 file
= state
->file
;
17649 line
= state
->line
;
17650 is_stmt
= state
->is_stmt
;
17651 discriminator
= state
->discriminator
;
17653 if (dwarf_line_debug
)
17655 fprintf_unfiltered (gdb_stdlog
,
17656 "Processing actual line %u: file %u,"
17657 " address %s, is_stmt %u, discrim %u\n",
17659 paddress (reader
->gdbarch
, state
->address
),
17660 is_stmt
, discriminator
);
17663 if (file
== 0 || file
- 1 >= lh
->num_file_names
)
17664 dwarf2_debug_line_missing_file_complaint ();
17665 /* For now we ignore lines not starting on an instruction boundary.
17666 But not when processing end_sequence for compatibility with the
17667 previous version of the code. */
17668 else if (state
->op_index
== 0 || end_sequence
)
17670 lh
->file_names
[file
- 1].included_p
= 1;
17671 if (reader
->record_lines_p
&& is_stmt
)
17673 if (state
->last_subfile
!= current_subfile
|| end_sequence
)
17675 dwarf_finish_line (reader
->gdbarch
, state
->last_subfile
,
17676 state
->address
, state
->record_line
);
17681 if (dwarf_record_line_p (line
, state
->last_line
,
17682 state
->line_has_non_zero_discriminator
,
17683 state
->last_subfile
))
17685 dwarf_record_line_1 (reader
->gdbarch
, current_subfile
,
17686 line
, state
->address
,
17687 state
->record_line
);
17689 state
->last_subfile
= current_subfile
;
17690 state
->last_line
= line
;
17696 /* Initialize STATE for the start of a line number program. */
17699 init_lnp_state_machine (lnp_state_machine
*state
,
17700 const lnp_reader_state
*reader
)
17702 memset (state
, 0, sizeof (*state
));
17704 /* Just starting, there is no "last file". */
17705 state
->last_file
= 0;
17706 state
->last_subfile
= NULL
;
17708 state
->record_line
= record_line
;
17710 state
->last_line
= 0;
17711 state
->line_has_non_zero_discriminator
= 0;
17713 /* Initialize these according to the DWARF spec. */
17714 state
->op_index
= 0;
17717 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
17718 was a line entry for it so that the backend has a chance to adjust it
17719 and also record it in case it needs it. This is currently used by MIPS
17720 code, cf. `mips_adjust_dwarf2_line'. */
17721 state
->address
= gdbarch_adjust_dwarf2_line (reader
->gdbarch
, 0, 0);
17722 state
->is_stmt
= reader
->line_header
->default_is_stmt
;
17723 state
->discriminator
= 0;
17726 /* Check address and if invalid nop-out the rest of the lines in this
17730 check_line_address (struct dwarf2_cu
*cu
, lnp_state_machine
*state
,
17731 const gdb_byte
*line_ptr
,
17732 CORE_ADDR lowpc
, CORE_ADDR address
)
17734 /* If address < lowpc then it's not a usable value, it's outside the
17735 pc range of the CU. However, we restrict the test to only address
17736 values of zero to preserve GDB's previous behaviour which is to
17737 handle the specific case of a function being GC'd by the linker. */
17739 if (address
== 0 && address
< lowpc
)
17741 /* This line table is for a function which has been
17742 GCd by the linker. Ignore it. PR gdb/12528 */
17744 struct objfile
*objfile
= cu
->objfile
;
17745 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
17747 complaint (&symfile_complaints
,
17748 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
17749 line_offset
, objfile_name (objfile
));
17750 state
->record_line
= noop_record_line
;
17751 /* Note: sm.record_line is left as noop_record_line
17752 until we see DW_LNE_end_sequence. */
17756 /* Subroutine of dwarf_decode_lines to simplify it.
17757 Process the line number information in LH.
17758 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
17759 program in order to set included_p for every referenced header. */
17762 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
17763 const int decode_for_pst_p
, CORE_ADDR lowpc
)
17765 const gdb_byte
*line_ptr
, *extended_end
;
17766 const gdb_byte
*line_end
;
17767 unsigned int bytes_read
, extended_len
;
17768 unsigned char op_code
, extended_op
;
17769 CORE_ADDR baseaddr
;
17770 struct objfile
*objfile
= cu
->objfile
;
17771 bfd
*abfd
= objfile
->obfd
;
17772 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17773 /* Non-zero if we're recording line info (as opposed to building partial
17775 int record_lines_p
= !decode_for_pst_p
;
17776 /* A collection of things we need to pass to dwarf_record_line. */
17777 lnp_reader_state reader_state
;
17779 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17781 line_ptr
= lh
->statement_program_start
;
17782 line_end
= lh
->statement_program_end
;
17784 reader_state
.gdbarch
= gdbarch
;
17785 reader_state
.line_header
= lh
;
17786 reader_state
.record_lines_p
= record_lines_p
;
17788 /* Read the statement sequences until there's nothing left. */
17789 while (line_ptr
< line_end
)
17791 /* The DWARF line number program state machine. */
17792 lnp_state_machine state_machine
;
17793 int end_sequence
= 0;
17795 /* Reset the state machine at the start of each sequence. */
17796 init_lnp_state_machine (&state_machine
, &reader_state
);
17798 if (record_lines_p
&& lh
->num_file_names
>= state_machine
.file
)
17800 /* Start a subfile for the current file of the state machine. */
17801 /* lh->include_dirs and lh->file_names are 0-based, but the
17802 directory and file name numbers in the statement program
17804 struct file_entry
*fe
= &lh
->file_names
[state_machine
.file
- 1];
17805 const char *dir
= NULL
;
17807 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
17808 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17810 dwarf2_start_subfile (fe
->name
, dir
);
17813 /* Decode the table. */
17814 while (line_ptr
< line_end
&& !end_sequence
)
17816 op_code
= read_1_byte (abfd
, line_ptr
);
17819 if (op_code
>= lh
->opcode_base
)
17821 /* Special opcode. */
17822 unsigned char adj_opcode
;
17823 CORE_ADDR addr_adj
;
17826 adj_opcode
= op_code
- lh
->opcode_base
;
17827 addr_adj
= (((state_machine
.op_index
17828 + (adj_opcode
/ lh
->line_range
))
17829 / lh
->maximum_ops_per_instruction
)
17830 * lh
->minimum_instruction_length
);
17831 state_machine
.address
17832 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17833 state_machine
.op_index
= ((state_machine
.op_index
17834 + (adj_opcode
/ lh
->line_range
))
17835 % lh
->maximum_ops_per_instruction
);
17836 line_delta
= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
17837 state_machine
.line
+= line_delta
;
17838 if (line_delta
!= 0)
17839 state_machine
.line_has_non_zero_discriminator
17840 = state_machine
.discriminator
!= 0;
17842 dwarf_record_line (&reader_state
, &state_machine
, 0);
17843 state_machine
.discriminator
= 0;
17845 else switch (op_code
)
17847 case DW_LNS_extended_op
:
17848 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
17850 line_ptr
+= bytes_read
;
17851 extended_end
= line_ptr
+ extended_len
;
17852 extended_op
= read_1_byte (abfd
, line_ptr
);
17854 switch (extended_op
)
17856 case DW_LNE_end_sequence
:
17857 state_machine
.record_line
= record_line
;
17860 case DW_LNE_set_address
:
17863 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
17865 line_ptr
+= bytes_read
;
17866 check_line_address (cu
, &state_machine
, line_ptr
,
17868 state_machine
.op_index
= 0;
17869 address
+= baseaddr
;
17870 state_machine
.address
17871 = gdbarch_adjust_dwarf2_line (gdbarch
, address
, 0);
17874 case DW_LNE_define_file
:
17876 const char *cur_file
;
17877 unsigned int dir_index
, mod_time
, length
;
17879 cur_file
= read_direct_string (abfd
, line_ptr
,
17881 line_ptr
+= bytes_read
;
17883 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17884 line_ptr
+= bytes_read
;
17886 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17887 line_ptr
+= bytes_read
;
17889 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17890 line_ptr
+= bytes_read
;
17891 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17894 case DW_LNE_set_discriminator
:
17895 /* The discriminator is not interesting to the debugger;
17896 just ignore it. We still need to check its value though:
17897 if there are consecutive entries for the same
17898 (non-prologue) line we want to coalesce them.
17900 state_machine
.discriminator
17901 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17902 state_machine
.line_has_non_zero_discriminator
17903 |= state_machine
.discriminator
!= 0;
17904 line_ptr
+= bytes_read
;
17907 complaint (&symfile_complaints
,
17908 _("mangled .debug_line section"));
17911 /* Make sure that we parsed the extended op correctly. If e.g.
17912 we expected a different address size than the producer used,
17913 we may have read the wrong number of bytes. */
17914 if (line_ptr
!= extended_end
)
17916 complaint (&symfile_complaints
,
17917 _("mangled .debug_line section"));
17922 dwarf_record_line (&reader_state
, &state_machine
, 0);
17923 state_machine
.discriminator
= 0;
17925 case DW_LNS_advance_pc
:
17928 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17929 CORE_ADDR addr_adj
;
17931 addr_adj
= (((state_machine
.op_index
+ adjust
)
17932 / lh
->maximum_ops_per_instruction
)
17933 * lh
->minimum_instruction_length
);
17934 state_machine
.address
17935 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17936 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
17937 % lh
->maximum_ops_per_instruction
);
17938 line_ptr
+= bytes_read
;
17941 case DW_LNS_advance_line
:
17944 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
17946 state_machine
.line
+= line_delta
;
17947 if (line_delta
!= 0)
17948 state_machine
.line_has_non_zero_discriminator
17949 = state_machine
.discriminator
!= 0;
17950 line_ptr
+= bytes_read
;
17953 case DW_LNS_set_file
:
17955 /* The arrays lh->include_dirs and lh->file_names are
17956 0-based, but the directory and file name numbers in
17957 the statement program are 1-based. */
17958 struct file_entry
*fe
;
17959 const char *dir
= NULL
;
17961 state_machine
.file
= read_unsigned_leb128 (abfd
, line_ptr
,
17963 line_ptr
+= bytes_read
;
17964 if (state_machine
.file
== 0
17965 || state_machine
.file
- 1 >= lh
->num_file_names
)
17966 dwarf2_debug_line_missing_file_complaint ();
17969 fe
= &lh
->file_names
[state_machine
.file
- 1];
17970 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
17971 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17972 if (record_lines_p
)
17974 state_machine
.last_subfile
= current_subfile
;
17975 state_machine
.line_has_non_zero_discriminator
17976 = state_machine
.discriminator
!= 0;
17977 dwarf2_start_subfile (fe
->name
, dir
);
17982 case DW_LNS_set_column
:
17983 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17984 line_ptr
+= bytes_read
;
17986 case DW_LNS_negate_stmt
:
17987 state_machine
.is_stmt
= (!state_machine
.is_stmt
);
17989 case DW_LNS_set_basic_block
:
17991 /* Add to the address register of the state machine the
17992 address increment value corresponding to special opcode
17993 255. I.e., this value is scaled by the minimum
17994 instruction length since special opcode 255 would have
17995 scaled the increment. */
17996 case DW_LNS_const_add_pc
:
17998 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
17999 CORE_ADDR addr_adj
;
18001 addr_adj
= (((state_machine
.op_index
+ adjust
)
18002 / lh
->maximum_ops_per_instruction
)
18003 * lh
->minimum_instruction_length
);
18004 state_machine
.address
18005 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18006 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
18007 % lh
->maximum_ops_per_instruction
);
18010 case DW_LNS_fixed_advance_pc
:
18012 CORE_ADDR addr_adj
;
18014 addr_adj
= read_2_bytes (abfd
, line_ptr
);
18015 state_machine
.address
18016 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18017 state_machine
.op_index
= 0;
18023 /* Unknown standard opcode, ignore it. */
18026 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
18028 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18029 line_ptr
+= bytes_read
;
18036 dwarf2_debug_line_missing_end_sequence_complaint ();
18038 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
18039 in which case we still finish recording the last line). */
18040 dwarf_record_line (&reader_state
, &state_machine
, 1);
18044 /* Decode the Line Number Program (LNP) for the given line_header
18045 structure and CU. The actual information extracted and the type
18046 of structures created from the LNP depends on the value of PST.
18048 1. If PST is NULL, then this procedure uses the data from the program
18049 to create all necessary symbol tables, and their linetables.
18051 2. If PST is not NULL, this procedure reads the program to determine
18052 the list of files included by the unit represented by PST, and
18053 builds all the associated partial symbol tables.
18055 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
18056 It is used for relative paths in the line table.
18057 NOTE: When processing partial symtabs (pst != NULL),
18058 comp_dir == pst->dirname.
18060 NOTE: It is important that psymtabs have the same file name (via strcmp)
18061 as the corresponding symtab. Since COMP_DIR is not used in the name of the
18062 symtab we don't use it in the name of the psymtabs we create.
18063 E.g. expand_line_sal requires this when finding psymtabs to expand.
18064 A good testcase for this is mb-inline.exp.
18066 LOWPC is the lowest address in CU (or 0 if not known).
18068 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
18069 for its PC<->lines mapping information. Otherwise only the filename
18070 table is read in. */
18073 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
18074 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
18075 CORE_ADDR lowpc
, int decode_mapping
)
18077 struct objfile
*objfile
= cu
->objfile
;
18078 const int decode_for_pst_p
= (pst
!= NULL
);
18080 if (decode_mapping
)
18081 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
18083 if (decode_for_pst_p
)
18087 /* Now that we're done scanning the Line Header Program, we can
18088 create the psymtab of each included file. */
18089 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
18090 if (lh
->file_names
[file_index
].included_p
== 1)
18092 const char *include_name
=
18093 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
18094 if (include_name
!= NULL
)
18095 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
18100 /* Make sure a symtab is created for every file, even files
18101 which contain only variables (i.e. no code with associated
18103 struct compunit_symtab
*cust
= buildsym_compunit_symtab ();
18106 for (i
= 0; i
< lh
->num_file_names
; i
++)
18108 const char *dir
= NULL
;
18109 struct file_entry
*fe
;
18111 fe
= &lh
->file_names
[i
];
18112 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
18113 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
18114 dwarf2_start_subfile (fe
->name
, dir
);
18116 if (current_subfile
->symtab
== NULL
)
18118 current_subfile
->symtab
18119 = allocate_symtab (cust
, current_subfile
->name
);
18121 fe
->symtab
= current_subfile
->symtab
;
18126 /* Start a subfile for DWARF. FILENAME is the name of the file and
18127 DIRNAME the name of the source directory which contains FILENAME
18128 or NULL if not known.
18129 This routine tries to keep line numbers from identical absolute and
18130 relative file names in a common subfile.
18132 Using the `list' example from the GDB testsuite, which resides in
18133 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
18134 of /srcdir/list0.c yields the following debugging information for list0.c:
18136 DW_AT_name: /srcdir/list0.c
18137 DW_AT_comp_dir: /compdir
18138 files.files[0].name: list0.h
18139 files.files[0].dir: /srcdir
18140 files.files[1].name: list0.c
18141 files.files[1].dir: /srcdir
18143 The line number information for list0.c has to end up in a single
18144 subfile, so that `break /srcdir/list0.c:1' works as expected.
18145 start_subfile will ensure that this happens provided that we pass the
18146 concatenation of files.files[1].dir and files.files[1].name as the
18150 dwarf2_start_subfile (const char *filename
, const char *dirname
)
18154 /* In order not to lose the line information directory,
18155 we concatenate it to the filename when it makes sense.
18156 Note that the Dwarf3 standard says (speaking of filenames in line
18157 information): ``The directory index is ignored for file names
18158 that represent full path names''. Thus ignoring dirname in the
18159 `else' branch below isn't an issue. */
18161 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
18163 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
18167 start_subfile (filename
);
18173 /* Start a symtab for DWARF.
18174 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
18176 static struct compunit_symtab
*
18177 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
18178 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
18180 struct compunit_symtab
*cust
18181 = start_symtab (cu
->objfile
, name
, comp_dir
, low_pc
);
18183 record_debugformat ("DWARF 2");
18184 record_producer (cu
->producer
);
18186 /* We assume that we're processing GCC output. */
18187 processing_gcc_compilation
= 2;
18189 cu
->processing_has_namespace_info
= 0;
18195 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
18196 struct dwarf2_cu
*cu
)
18198 struct objfile
*objfile
= cu
->objfile
;
18199 struct comp_unit_head
*cu_header
= &cu
->header
;
18201 /* NOTE drow/2003-01-30: There used to be a comment and some special
18202 code here to turn a symbol with DW_AT_external and a
18203 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
18204 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
18205 with some versions of binutils) where shared libraries could have
18206 relocations against symbols in their debug information - the
18207 minimal symbol would have the right address, but the debug info
18208 would not. It's no longer necessary, because we will explicitly
18209 apply relocations when we read in the debug information now. */
18211 /* A DW_AT_location attribute with no contents indicates that a
18212 variable has been optimized away. */
18213 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
18215 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18219 /* Handle one degenerate form of location expression specially, to
18220 preserve GDB's previous behavior when section offsets are
18221 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
18222 then mark this symbol as LOC_STATIC. */
18224 if (attr_form_is_block (attr
)
18225 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
18226 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
18227 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
18228 && (DW_BLOCK (attr
)->size
18229 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
18231 unsigned int dummy
;
18233 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
18234 SYMBOL_VALUE_ADDRESS (sym
) =
18235 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
18237 SYMBOL_VALUE_ADDRESS (sym
) =
18238 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
18239 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
18240 fixup_symbol_section (sym
, objfile
);
18241 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
18242 SYMBOL_SECTION (sym
));
18246 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
18247 expression evaluator, and use LOC_COMPUTED only when necessary
18248 (i.e. when the value of a register or memory location is
18249 referenced, or a thread-local block, etc.). Then again, it might
18250 not be worthwhile. I'm assuming that it isn't unless performance
18251 or memory numbers show me otherwise. */
18253 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
18255 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
18256 cu
->has_loclist
= 1;
18259 /* Given a pointer to a DWARF information entry, figure out if we need
18260 to make a symbol table entry for it, and if so, create a new entry
18261 and return a pointer to it.
18262 If TYPE is NULL, determine symbol type from the die, otherwise
18263 used the passed type.
18264 If SPACE is not NULL, use it to hold the new symbol. If it is
18265 NULL, allocate a new symbol on the objfile's obstack. */
18267 static struct symbol
*
18268 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
18269 struct symbol
*space
)
18271 struct objfile
*objfile
= cu
->objfile
;
18272 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18273 struct symbol
*sym
= NULL
;
18275 struct attribute
*attr
= NULL
;
18276 struct attribute
*attr2
= NULL
;
18277 CORE_ADDR baseaddr
;
18278 struct pending
**list_to_add
= NULL
;
18280 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
18282 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
18284 name
= dwarf2_name (die
, cu
);
18287 const char *linkagename
;
18288 int suppress_add
= 0;
18293 sym
= allocate_symbol (objfile
);
18294 OBJSTAT (objfile
, n_syms
++);
18296 /* Cache this symbol's name and the name's demangled form (if any). */
18297 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
18298 linkagename
= dwarf2_physname (name
, die
, cu
);
18299 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
18301 /* Fortran does not have mangling standard and the mangling does differ
18302 between gfortran, iFort etc. */
18303 if (cu
->language
== language_fortran
18304 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
18305 symbol_set_demangled_name (&(sym
->ginfo
),
18306 dwarf2_full_name (name
, die
, cu
),
18309 /* Default assumptions.
18310 Use the passed type or decode it from the die. */
18311 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18312 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18314 SYMBOL_TYPE (sym
) = type
;
18316 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
18317 attr
= dwarf2_attr (die
,
18318 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
18322 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
18325 attr
= dwarf2_attr (die
,
18326 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
18330 int file_index
= DW_UNSND (attr
);
18332 if (cu
->line_header
== NULL
18333 || file_index
> cu
->line_header
->num_file_names
)
18334 complaint (&symfile_complaints
,
18335 _("file index out of range"));
18336 else if (file_index
> 0)
18338 struct file_entry
*fe
;
18340 fe
= &cu
->line_header
->file_names
[file_index
- 1];
18341 symbol_set_symtab (sym
, fe
->symtab
);
18348 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
18353 addr
= attr_value_as_address (attr
);
18354 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
18355 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
18357 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
18358 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
18359 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
18360 add_symbol_to_list (sym
, cu
->list_in_scope
);
18362 case DW_TAG_subprogram
:
18363 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18365 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18366 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18367 if ((attr2
&& (DW_UNSND (attr2
) != 0))
18368 || cu
->language
== language_ada
)
18370 /* Subprograms marked external are stored as a global symbol.
18371 Ada subprograms, whether marked external or not, are always
18372 stored as a global symbol, because we want to be able to
18373 access them globally. For instance, we want to be able
18374 to break on a nested subprogram without having to
18375 specify the context. */
18376 list_to_add
= &global_symbols
;
18380 list_to_add
= cu
->list_in_scope
;
18383 case DW_TAG_inlined_subroutine
:
18384 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18386 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18387 SYMBOL_INLINED (sym
) = 1;
18388 list_to_add
= cu
->list_in_scope
;
18390 case DW_TAG_template_value_param
:
18392 /* Fall through. */
18393 case DW_TAG_constant
:
18394 case DW_TAG_variable
:
18395 case DW_TAG_member
:
18396 /* Compilation with minimal debug info may result in
18397 variables with missing type entries. Change the
18398 misleading `void' type to something sensible. */
18399 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
18401 = objfile_type (objfile
)->nodebug_data_symbol
;
18403 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18404 /* In the case of DW_TAG_member, we should only be called for
18405 static const members. */
18406 if (die
->tag
== DW_TAG_member
)
18408 /* dwarf2_add_field uses die_is_declaration,
18409 so we do the same. */
18410 gdb_assert (die_is_declaration (die
, cu
));
18415 dwarf2_const_value (attr
, sym
, cu
);
18416 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18419 if (attr2
&& (DW_UNSND (attr2
) != 0))
18420 list_to_add
= &global_symbols
;
18422 list_to_add
= cu
->list_in_scope
;
18426 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18429 var_decode_location (attr
, sym
, cu
);
18430 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18432 /* Fortran explicitly imports any global symbols to the local
18433 scope by DW_TAG_common_block. */
18434 if (cu
->language
== language_fortran
&& die
->parent
18435 && die
->parent
->tag
== DW_TAG_common_block
)
18438 if (SYMBOL_CLASS (sym
) == LOC_STATIC
18439 && SYMBOL_VALUE_ADDRESS (sym
) == 0
18440 && !dwarf2_per_objfile
->has_section_at_zero
)
18442 /* When a static variable is eliminated by the linker,
18443 the corresponding debug information is not stripped
18444 out, but the variable address is set to null;
18445 do not add such variables into symbol table. */
18447 else if (attr2
&& (DW_UNSND (attr2
) != 0))
18449 /* Workaround gfortran PR debug/40040 - it uses
18450 DW_AT_location for variables in -fPIC libraries which may
18451 get overriden by other libraries/executable and get
18452 a different address. Resolve it by the minimal symbol
18453 which may come from inferior's executable using copy
18454 relocation. Make this workaround only for gfortran as for
18455 other compilers GDB cannot guess the minimal symbol
18456 Fortran mangling kind. */
18457 if (cu
->language
== language_fortran
&& die
->parent
18458 && die
->parent
->tag
== DW_TAG_module
18460 && startswith (cu
->producer
, "GNU Fortran "))
18461 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18463 /* A variable with DW_AT_external is never static,
18464 but it may be block-scoped. */
18465 list_to_add
= (cu
->list_in_scope
== &file_symbols
18466 ? &global_symbols
: cu
->list_in_scope
);
18469 list_to_add
= cu
->list_in_scope
;
18473 /* We do not know the address of this symbol.
18474 If it is an external symbol and we have type information
18475 for it, enter the symbol as a LOC_UNRESOLVED symbol.
18476 The address of the variable will then be determined from
18477 the minimal symbol table whenever the variable is
18479 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18481 /* Fortran explicitly imports any global symbols to the local
18482 scope by DW_TAG_common_block. */
18483 if (cu
->language
== language_fortran
&& die
->parent
18484 && die
->parent
->tag
== DW_TAG_common_block
)
18486 /* SYMBOL_CLASS doesn't matter here because
18487 read_common_block is going to reset it. */
18489 list_to_add
= cu
->list_in_scope
;
18491 else if (attr2
&& (DW_UNSND (attr2
) != 0)
18492 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
18494 /* A variable with DW_AT_external is never static, but it
18495 may be block-scoped. */
18496 list_to_add
= (cu
->list_in_scope
== &file_symbols
18497 ? &global_symbols
: cu
->list_in_scope
);
18499 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18501 else if (!die_is_declaration (die
, cu
))
18503 /* Use the default LOC_OPTIMIZED_OUT class. */
18504 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
18506 list_to_add
= cu
->list_in_scope
;
18510 case DW_TAG_formal_parameter
:
18511 /* If we are inside a function, mark this as an argument. If
18512 not, we might be looking at an argument to an inlined function
18513 when we do not have enough information to show inlined frames;
18514 pretend it's a local variable in that case so that the user can
18516 if (context_stack_depth
> 0
18517 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
18518 SYMBOL_IS_ARGUMENT (sym
) = 1;
18519 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18522 var_decode_location (attr
, sym
, cu
);
18524 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18527 dwarf2_const_value (attr
, sym
, cu
);
18530 list_to_add
= cu
->list_in_scope
;
18532 case DW_TAG_unspecified_parameters
:
18533 /* From varargs functions; gdb doesn't seem to have any
18534 interest in this information, so just ignore it for now.
18537 case DW_TAG_template_type_param
:
18539 /* Fall through. */
18540 case DW_TAG_class_type
:
18541 case DW_TAG_interface_type
:
18542 case DW_TAG_structure_type
:
18543 case DW_TAG_union_type
:
18544 case DW_TAG_set_type
:
18545 case DW_TAG_enumeration_type
:
18546 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18547 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
18550 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
18551 really ever be static objects: otherwise, if you try
18552 to, say, break of a class's method and you're in a file
18553 which doesn't mention that class, it won't work unless
18554 the check for all static symbols in lookup_symbol_aux
18555 saves you. See the OtherFileClass tests in
18556 gdb.c++/namespace.exp. */
18560 list_to_add
= (cu
->list_in_scope
== &file_symbols
18561 && (cu
->language
== language_cplus
18562 || cu
->language
== language_java
)
18563 ? &global_symbols
: cu
->list_in_scope
);
18565 /* The semantics of C++ state that "struct foo {
18566 ... }" also defines a typedef for "foo". A Java
18567 class declaration also defines a typedef for the
18569 if (cu
->language
== language_cplus
18570 || cu
->language
== language_java
18571 || cu
->language
== language_ada
18572 || cu
->language
== language_d
)
18574 /* The symbol's name is already allocated along
18575 with this objfile, so we don't need to
18576 duplicate it for the type. */
18577 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
18578 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
18583 case DW_TAG_typedef
:
18584 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18585 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18586 list_to_add
= cu
->list_in_scope
;
18588 case DW_TAG_base_type
:
18589 case DW_TAG_subrange_type
:
18590 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18591 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18592 list_to_add
= cu
->list_in_scope
;
18594 case DW_TAG_enumerator
:
18595 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18598 dwarf2_const_value (attr
, sym
, cu
);
18601 /* NOTE: carlton/2003-11-10: See comment above in the
18602 DW_TAG_class_type, etc. block. */
18604 list_to_add
= (cu
->list_in_scope
== &file_symbols
18605 && (cu
->language
== language_cplus
18606 || cu
->language
== language_java
)
18607 ? &global_symbols
: cu
->list_in_scope
);
18610 case DW_TAG_imported_declaration
:
18611 case DW_TAG_namespace
:
18612 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18613 list_to_add
= &global_symbols
;
18615 case DW_TAG_module
:
18616 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18617 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
18618 list_to_add
= &global_symbols
;
18620 case DW_TAG_common_block
:
18621 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
18622 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
18623 add_symbol_to_list (sym
, cu
->list_in_scope
);
18626 /* Not a tag we recognize. Hopefully we aren't processing
18627 trash data, but since we must specifically ignore things
18628 we don't recognize, there is nothing else we should do at
18630 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
18631 dwarf_tag_name (die
->tag
));
18637 sym
->hash_next
= objfile
->template_symbols
;
18638 objfile
->template_symbols
= sym
;
18639 list_to_add
= NULL
;
18642 if (list_to_add
!= NULL
)
18643 add_symbol_to_list (sym
, list_to_add
);
18645 /* For the benefit of old versions of GCC, check for anonymous
18646 namespaces based on the demangled name. */
18647 if (!cu
->processing_has_namespace_info
18648 && cu
->language
== language_cplus
)
18649 cp_scan_for_anonymous_namespaces (sym
, objfile
);
18654 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18656 static struct symbol
*
18657 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
18659 return new_symbol_full (die
, type
, cu
, NULL
);
18662 /* Given an attr with a DW_FORM_dataN value in host byte order,
18663 zero-extend it as appropriate for the symbol's type. The DWARF
18664 standard (v4) is not entirely clear about the meaning of using
18665 DW_FORM_dataN for a constant with a signed type, where the type is
18666 wider than the data. The conclusion of a discussion on the DWARF
18667 list was that this is unspecified. We choose to always zero-extend
18668 because that is the interpretation long in use by GCC. */
18671 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
18672 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
18674 struct objfile
*objfile
= cu
->objfile
;
18675 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
18676 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
18677 LONGEST l
= DW_UNSND (attr
);
18679 if (bits
< sizeof (*value
) * 8)
18681 l
&= ((LONGEST
) 1 << bits
) - 1;
18684 else if (bits
== sizeof (*value
) * 8)
18688 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
18689 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
18696 /* Read a constant value from an attribute. Either set *VALUE, or if
18697 the value does not fit in *VALUE, set *BYTES - either already
18698 allocated on the objfile obstack, or newly allocated on OBSTACK,
18699 or, set *BATON, if we translated the constant to a location
18703 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
18704 const char *name
, struct obstack
*obstack
,
18705 struct dwarf2_cu
*cu
,
18706 LONGEST
*value
, const gdb_byte
**bytes
,
18707 struct dwarf2_locexpr_baton
**baton
)
18709 struct objfile
*objfile
= cu
->objfile
;
18710 struct comp_unit_head
*cu_header
= &cu
->header
;
18711 struct dwarf_block
*blk
;
18712 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
18713 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
18719 switch (attr
->form
)
18722 case DW_FORM_GNU_addr_index
:
18726 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
18727 dwarf2_const_value_length_mismatch_complaint (name
,
18728 cu_header
->addr_size
,
18729 TYPE_LENGTH (type
));
18730 /* Symbols of this form are reasonably rare, so we just
18731 piggyback on the existing location code rather than writing
18732 a new implementation of symbol_computed_ops. */
18733 *baton
= obstack_alloc (obstack
, sizeof (struct dwarf2_locexpr_baton
));
18734 (*baton
)->per_cu
= cu
->per_cu
;
18735 gdb_assert ((*baton
)->per_cu
);
18737 (*baton
)->size
= 2 + cu_header
->addr_size
;
18738 data
= obstack_alloc (obstack
, (*baton
)->size
);
18739 (*baton
)->data
= data
;
18741 data
[0] = DW_OP_addr
;
18742 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
18743 byte_order
, DW_ADDR (attr
));
18744 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
18747 case DW_FORM_string
:
18749 case DW_FORM_GNU_str_index
:
18750 case DW_FORM_GNU_strp_alt
:
18751 /* DW_STRING is already allocated on the objfile obstack, point
18753 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
18755 case DW_FORM_block1
:
18756 case DW_FORM_block2
:
18757 case DW_FORM_block4
:
18758 case DW_FORM_block
:
18759 case DW_FORM_exprloc
:
18760 blk
= DW_BLOCK (attr
);
18761 if (TYPE_LENGTH (type
) != blk
->size
)
18762 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
18763 TYPE_LENGTH (type
));
18764 *bytes
= blk
->data
;
18767 /* The DW_AT_const_value attributes are supposed to carry the
18768 symbol's value "represented as it would be on the target
18769 architecture." By the time we get here, it's already been
18770 converted to host endianness, so we just need to sign- or
18771 zero-extend it as appropriate. */
18772 case DW_FORM_data1
:
18773 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
18775 case DW_FORM_data2
:
18776 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
18778 case DW_FORM_data4
:
18779 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
18781 case DW_FORM_data8
:
18782 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
18785 case DW_FORM_sdata
:
18786 *value
= DW_SND (attr
);
18789 case DW_FORM_udata
:
18790 *value
= DW_UNSND (attr
);
18794 complaint (&symfile_complaints
,
18795 _("unsupported const value attribute form: '%s'"),
18796 dwarf_form_name (attr
->form
));
18803 /* Copy constant value from an attribute to a symbol. */
18806 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
18807 struct dwarf2_cu
*cu
)
18809 struct objfile
*objfile
= cu
->objfile
;
18810 struct comp_unit_head
*cu_header
= &cu
->header
;
18812 const gdb_byte
*bytes
;
18813 struct dwarf2_locexpr_baton
*baton
;
18815 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
18816 SYMBOL_PRINT_NAME (sym
),
18817 &objfile
->objfile_obstack
, cu
,
18818 &value
, &bytes
, &baton
);
18822 SYMBOL_LOCATION_BATON (sym
) = baton
;
18823 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
18825 else if (bytes
!= NULL
)
18827 SYMBOL_VALUE_BYTES (sym
) = bytes
;
18828 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
18832 SYMBOL_VALUE (sym
) = value
;
18833 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
18837 /* Return the type of the die in question using its DW_AT_type attribute. */
18839 static struct type
*
18840 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18842 struct attribute
*type_attr
;
18844 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
18847 /* A missing DW_AT_type represents a void type. */
18848 return objfile_type (cu
->objfile
)->builtin_void
;
18851 return lookup_die_type (die
, type_attr
, cu
);
18854 /* True iff CU's producer generates GNAT Ada auxiliary information
18855 that allows to find parallel types through that information instead
18856 of having to do expensive parallel lookups by type name. */
18859 need_gnat_info (struct dwarf2_cu
*cu
)
18861 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18862 of GNAT produces this auxiliary information, without any indication
18863 that it is produced. Part of enhancing the FSF version of GNAT
18864 to produce that information will be to put in place an indicator
18865 that we can use in order to determine whether the descriptive type
18866 info is available or not. One suggestion that has been made is
18867 to use a new attribute, attached to the CU die. For now, assume
18868 that the descriptive type info is not available. */
18872 /* Return the auxiliary type of the die in question using its
18873 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18874 attribute is not present. */
18876 static struct type
*
18877 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18879 struct attribute
*type_attr
;
18881 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
18885 return lookup_die_type (die
, type_attr
, cu
);
18888 /* If DIE has a descriptive_type attribute, then set the TYPE's
18889 descriptive type accordingly. */
18892 set_descriptive_type (struct type
*type
, struct die_info
*die
,
18893 struct dwarf2_cu
*cu
)
18895 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
18897 if (descriptive_type
)
18899 ALLOCATE_GNAT_AUX_TYPE (type
);
18900 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
18904 /* Return the containing type of the die in question using its
18905 DW_AT_containing_type attribute. */
18907 static struct type
*
18908 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18910 struct attribute
*type_attr
;
18912 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
18914 error (_("Dwarf Error: Problem turning containing type into gdb type "
18915 "[in module %s]"), objfile_name (cu
->objfile
));
18917 return lookup_die_type (die
, type_attr
, cu
);
18920 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18922 static struct type
*
18923 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
18925 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18926 char *message
, *saved
;
18928 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18929 objfile_name (objfile
),
18930 cu
->header
.offset
.sect_off
,
18931 die
->offset
.sect_off
);
18932 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
18933 message
, strlen (message
));
18936 return init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
18939 /* Look up the type of DIE in CU using its type attribute ATTR.
18940 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18941 DW_AT_containing_type.
18942 If there is no type substitute an error marker. */
18944 static struct type
*
18945 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
18946 struct dwarf2_cu
*cu
)
18948 struct objfile
*objfile
= cu
->objfile
;
18949 struct type
*this_type
;
18951 gdb_assert (attr
->name
== DW_AT_type
18952 || attr
->name
== DW_AT_GNAT_descriptive_type
18953 || attr
->name
== DW_AT_containing_type
);
18955 /* First see if we have it cached. */
18957 if (attr
->form
== DW_FORM_GNU_ref_alt
)
18959 struct dwarf2_per_cu_data
*per_cu
;
18960 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18962 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
18963 this_type
= get_die_type_at_offset (offset
, per_cu
);
18965 else if (attr_form_is_ref (attr
))
18967 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18969 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
18971 else if (attr
->form
== DW_FORM_ref_sig8
)
18973 ULONGEST signature
= DW_SIGNATURE (attr
);
18975 return get_signatured_type (die
, signature
, cu
);
18979 complaint (&symfile_complaints
,
18980 _("Dwarf Error: Bad type attribute %s in DIE"
18981 " at 0x%x [in module %s]"),
18982 dwarf_attr_name (attr
->name
), die
->offset
.sect_off
,
18983 objfile_name (objfile
));
18984 return build_error_marker_type (cu
, die
);
18987 /* If not cached we need to read it in. */
18989 if (this_type
== NULL
)
18991 struct die_info
*type_die
= NULL
;
18992 struct dwarf2_cu
*type_cu
= cu
;
18994 if (attr_form_is_ref (attr
))
18995 type_die
= follow_die_ref (die
, attr
, &type_cu
);
18996 if (type_die
== NULL
)
18997 return build_error_marker_type (cu
, die
);
18998 /* If we find the type now, it's probably because the type came
18999 from an inter-CU reference and the type's CU got expanded before
19001 this_type
= read_type_die (type_die
, type_cu
);
19004 /* If we still don't have a type use an error marker. */
19006 if (this_type
== NULL
)
19007 return build_error_marker_type (cu
, die
);
19012 /* Return the type in DIE, CU.
19013 Returns NULL for invalid types.
19015 This first does a lookup in die_type_hash,
19016 and only reads the die in if necessary.
19018 NOTE: This can be called when reading in partial or full symbols. */
19020 static struct type
*
19021 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
19023 struct type
*this_type
;
19025 this_type
= get_die_type (die
, cu
);
19029 return read_type_die_1 (die
, cu
);
19032 /* Read the type in DIE, CU.
19033 Returns NULL for invalid types. */
19035 static struct type
*
19036 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
19038 struct type
*this_type
= NULL
;
19042 case DW_TAG_class_type
:
19043 case DW_TAG_interface_type
:
19044 case DW_TAG_structure_type
:
19045 case DW_TAG_union_type
:
19046 this_type
= read_structure_type (die
, cu
);
19048 case DW_TAG_enumeration_type
:
19049 this_type
= read_enumeration_type (die
, cu
);
19051 case DW_TAG_subprogram
:
19052 case DW_TAG_subroutine_type
:
19053 case DW_TAG_inlined_subroutine
:
19054 this_type
= read_subroutine_type (die
, cu
);
19056 case DW_TAG_array_type
:
19057 this_type
= read_array_type (die
, cu
);
19059 case DW_TAG_set_type
:
19060 this_type
= read_set_type (die
, cu
);
19062 case DW_TAG_pointer_type
:
19063 this_type
= read_tag_pointer_type (die
, cu
);
19065 case DW_TAG_ptr_to_member_type
:
19066 this_type
= read_tag_ptr_to_member_type (die
, cu
);
19068 case DW_TAG_reference_type
:
19069 this_type
= read_tag_reference_type (die
, cu
);
19071 case DW_TAG_const_type
:
19072 this_type
= read_tag_const_type (die
, cu
);
19074 case DW_TAG_volatile_type
:
19075 this_type
= read_tag_volatile_type (die
, cu
);
19077 case DW_TAG_restrict_type
:
19078 this_type
= read_tag_restrict_type (die
, cu
);
19080 case DW_TAG_string_type
:
19081 this_type
= read_tag_string_type (die
, cu
);
19083 case DW_TAG_typedef
:
19084 this_type
= read_typedef (die
, cu
);
19086 case DW_TAG_subrange_type
:
19087 this_type
= read_subrange_type (die
, cu
);
19089 case DW_TAG_base_type
:
19090 this_type
= read_base_type (die
, cu
);
19092 case DW_TAG_unspecified_type
:
19093 this_type
= read_unspecified_type (die
, cu
);
19095 case DW_TAG_namespace
:
19096 this_type
= read_namespace_type (die
, cu
);
19098 case DW_TAG_module
:
19099 this_type
= read_module_type (die
, cu
);
19101 case DW_TAG_atomic_type
:
19102 this_type
= read_tag_atomic_type (die
, cu
);
19105 complaint (&symfile_complaints
,
19106 _("unexpected tag in read_type_die: '%s'"),
19107 dwarf_tag_name (die
->tag
));
19114 /* See if we can figure out if the class lives in a namespace. We do
19115 this by looking for a member function; its demangled name will
19116 contain namespace info, if there is any.
19117 Return the computed name or NULL.
19118 Space for the result is allocated on the objfile's obstack.
19119 This is the full-die version of guess_partial_die_structure_name.
19120 In this case we know DIE has no useful parent. */
19123 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19125 struct die_info
*spec_die
;
19126 struct dwarf2_cu
*spec_cu
;
19127 struct die_info
*child
;
19130 spec_die
= die_specification (die
, &spec_cu
);
19131 if (spec_die
!= NULL
)
19137 for (child
= die
->child
;
19139 child
= child
->sibling
)
19141 if (child
->tag
== DW_TAG_subprogram
)
19143 struct attribute
*attr
;
19145 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
19147 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
19151 = language_class_name_from_physname (cu
->language_defn
,
19155 if (actual_name
!= NULL
)
19157 const char *die_name
= dwarf2_name (die
, cu
);
19159 if (die_name
!= NULL
19160 && strcmp (die_name
, actual_name
) != 0)
19162 /* Strip off the class name from the full name.
19163 We want the prefix. */
19164 int die_name_len
= strlen (die_name
);
19165 int actual_name_len
= strlen (actual_name
);
19167 /* Test for '::' as a sanity check. */
19168 if (actual_name_len
> die_name_len
+ 2
19169 && actual_name
[actual_name_len
19170 - die_name_len
- 1] == ':')
19172 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19174 actual_name_len
- die_name_len
- 2);
19177 xfree (actual_name
);
19186 /* GCC might emit a nameless typedef that has a linkage name. Determine the
19187 prefix part in such case. See
19188 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19191 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19193 struct attribute
*attr
;
19196 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
19197 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
19200 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19201 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19204 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19206 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19207 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19210 /* dwarf2_name had to be already called. */
19211 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
19213 /* Strip the base name, keep any leading namespaces/classes. */
19214 base
= strrchr (DW_STRING (attr
), ':');
19215 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
19218 return obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19219 DW_STRING (attr
), &base
[-1] - DW_STRING (attr
));
19222 /* Return the name of the namespace/class that DIE is defined within,
19223 or "" if we can't tell. The caller should not xfree the result.
19225 For example, if we're within the method foo() in the following
19235 then determine_prefix on foo's die will return "N::C". */
19237 static const char *
19238 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19240 struct die_info
*parent
, *spec_die
;
19241 struct dwarf2_cu
*spec_cu
;
19242 struct type
*parent_type
;
19245 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
19246 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
)
19249 retval
= anonymous_struct_prefix (die
, cu
);
19253 /* We have to be careful in the presence of DW_AT_specification.
19254 For example, with GCC 3.4, given the code
19258 // Definition of N::foo.
19262 then we'll have a tree of DIEs like this:
19264 1: DW_TAG_compile_unit
19265 2: DW_TAG_namespace // N
19266 3: DW_TAG_subprogram // declaration of N::foo
19267 4: DW_TAG_subprogram // definition of N::foo
19268 DW_AT_specification // refers to die #3
19270 Thus, when processing die #4, we have to pretend that we're in
19271 the context of its DW_AT_specification, namely the contex of die
19274 spec_die
= die_specification (die
, &spec_cu
);
19275 if (spec_die
== NULL
)
19276 parent
= die
->parent
;
19279 parent
= spec_die
->parent
;
19283 if (parent
== NULL
)
19285 else if (parent
->building_fullname
)
19288 const char *parent_name
;
19290 /* It has been seen on RealView 2.2 built binaries,
19291 DW_TAG_template_type_param types actually _defined_ as
19292 children of the parent class:
19295 template class <class Enum> Class{};
19296 Class<enum E> class_e;
19298 1: DW_TAG_class_type (Class)
19299 2: DW_TAG_enumeration_type (E)
19300 3: DW_TAG_enumerator (enum1:0)
19301 3: DW_TAG_enumerator (enum2:1)
19303 2: DW_TAG_template_type_param
19304 DW_AT_type DW_FORM_ref_udata (E)
19306 Besides being broken debug info, it can put GDB into an
19307 infinite loop. Consider:
19309 When we're building the full name for Class<E>, we'll start
19310 at Class, and go look over its template type parameters,
19311 finding E. We'll then try to build the full name of E, and
19312 reach here. We're now trying to build the full name of E,
19313 and look over the parent DIE for containing scope. In the
19314 broken case, if we followed the parent DIE of E, we'd again
19315 find Class, and once again go look at its template type
19316 arguments, etc., etc. Simply don't consider such parent die
19317 as source-level parent of this die (it can't be, the language
19318 doesn't allow it), and break the loop here. */
19319 name
= dwarf2_name (die
, cu
);
19320 parent_name
= dwarf2_name (parent
, cu
);
19321 complaint (&symfile_complaints
,
19322 _("template param type '%s' defined within parent '%s'"),
19323 name
? name
: "<unknown>",
19324 parent_name
? parent_name
: "<unknown>");
19328 switch (parent
->tag
)
19330 case DW_TAG_namespace
:
19331 parent_type
= read_type_die (parent
, cu
);
19332 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
19333 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
19334 Work around this problem here. */
19335 if (cu
->language
== language_cplus
19336 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
19338 /* We give a name to even anonymous namespaces. */
19339 return TYPE_TAG_NAME (parent_type
);
19340 case DW_TAG_class_type
:
19341 case DW_TAG_interface_type
:
19342 case DW_TAG_structure_type
:
19343 case DW_TAG_union_type
:
19344 case DW_TAG_module
:
19345 parent_type
= read_type_die (parent
, cu
);
19346 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19347 return TYPE_TAG_NAME (parent_type
);
19349 /* An anonymous structure is only allowed non-static data
19350 members; no typedefs, no member functions, et cetera.
19351 So it does not need a prefix. */
19353 case DW_TAG_compile_unit
:
19354 case DW_TAG_partial_unit
:
19355 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
19356 if (cu
->language
== language_cplus
19357 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
19358 && die
->child
!= NULL
19359 && (die
->tag
== DW_TAG_class_type
19360 || die
->tag
== DW_TAG_structure_type
19361 || die
->tag
== DW_TAG_union_type
))
19363 char *name
= guess_full_die_structure_name (die
, cu
);
19368 case DW_TAG_enumeration_type
:
19369 parent_type
= read_type_die (parent
, cu
);
19370 if (TYPE_DECLARED_CLASS (parent_type
))
19372 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19373 return TYPE_TAG_NAME (parent_type
);
19376 /* Fall through. */
19378 return determine_prefix (parent
, cu
);
19382 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
19383 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
19384 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
19385 an obconcat, otherwise allocate storage for the result. The CU argument is
19386 used to determine the language and hence, the appropriate separator. */
19388 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
19391 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
19392 int physname
, struct dwarf2_cu
*cu
)
19394 const char *lead
= "";
19397 if (suffix
== NULL
|| suffix
[0] == '\0'
19398 || prefix
== NULL
|| prefix
[0] == '\0')
19400 else if (cu
->language
== language_java
)
19402 else if (cu
->language
== language_d
)
19404 /* For D, the 'main' function could be defined in any module, but it
19405 should never be prefixed. */
19406 if (strcmp (suffix
, "D main") == 0)
19414 else if (cu
->language
== language_fortran
&& physname
)
19416 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
19417 DW_AT_MIPS_linkage_name is preferred and used instead. */
19425 if (prefix
== NULL
)
19427 if (suffix
== NULL
)
19433 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
19435 strcpy (retval
, lead
);
19436 strcat (retval
, prefix
);
19437 strcat (retval
, sep
);
19438 strcat (retval
, suffix
);
19443 /* We have an obstack. */
19444 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
19448 /* Return sibling of die, NULL if no sibling. */
19450 static struct die_info
*
19451 sibling_die (struct die_info
*die
)
19453 return die
->sibling
;
19456 /* Get name of a die, return NULL if not found. */
19458 static const char *
19459 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
19460 struct obstack
*obstack
)
19462 if (name
&& cu
->language
== language_cplus
)
19464 char *canon_name
= cp_canonicalize_string (name
);
19466 if (canon_name
!= NULL
)
19468 if (strcmp (canon_name
, name
) != 0)
19469 name
= obstack_copy0 (obstack
, canon_name
, strlen (canon_name
));
19470 xfree (canon_name
);
19477 /* Get name of a die, return NULL if not found.
19478 Anonymous namespaces are converted to their magic string. */
19480 static const char *
19481 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19483 struct attribute
*attr
;
19485 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19486 if ((!attr
|| !DW_STRING (attr
))
19487 && die
->tag
!= DW_TAG_namespace
19488 && die
->tag
!= DW_TAG_class_type
19489 && die
->tag
!= DW_TAG_interface_type
19490 && die
->tag
!= DW_TAG_structure_type
19491 && die
->tag
!= DW_TAG_union_type
)
19496 case DW_TAG_compile_unit
:
19497 case DW_TAG_partial_unit
:
19498 /* Compilation units have a DW_AT_name that is a filename, not
19499 a source language identifier. */
19500 case DW_TAG_enumeration_type
:
19501 case DW_TAG_enumerator
:
19502 /* These tags always have simple identifiers already; no need
19503 to canonicalize them. */
19504 return DW_STRING (attr
);
19506 case DW_TAG_namespace
:
19507 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19508 return DW_STRING (attr
);
19509 return CP_ANONYMOUS_NAMESPACE_STR
;
19511 case DW_TAG_subprogram
:
19512 /* Java constructors will all be named "<init>", so return
19513 the class name when we see this special case. */
19514 if (cu
->language
== language_java
19515 && DW_STRING (attr
) != NULL
19516 && strcmp (DW_STRING (attr
), "<init>") == 0)
19518 struct dwarf2_cu
*spec_cu
= cu
;
19519 struct die_info
*spec_die
;
19521 /* GCJ will output '<init>' for Java constructor names.
19522 For this special case, return the name of the parent class. */
19524 /* GCJ may output subprogram DIEs with AT_specification set.
19525 If so, use the name of the specified DIE. */
19526 spec_die
= die_specification (die
, &spec_cu
);
19527 if (spec_die
!= NULL
)
19528 return dwarf2_name (spec_die
, spec_cu
);
19533 if (die
->tag
== DW_TAG_class_type
)
19534 return dwarf2_name (die
, cu
);
19536 while (die
->tag
!= DW_TAG_compile_unit
19537 && die
->tag
!= DW_TAG_partial_unit
);
19541 case DW_TAG_class_type
:
19542 case DW_TAG_interface_type
:
19543 case DW_TAG_structure_type
:
19544 case DW_TAG_union_type
:
19545 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19546 structures or unions. These were of the form "._%d" in GCC 4.1,
19547 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19548 and GCC 4.4. We work around this problem by ignoring these. */
19549 if (attr
&& DW_STRING (attr
)
19550 && (startswith (DW_STRING (attr
), "._")
19551 || startswith (DW_STRING (attr
), "<anonymous")))
19554 /* GCC might emit a nameless typedef that has a linkage name. See
19555 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19556 if (!attr
|| DW_STRING (attr
) == NULL
)
19558 char *demangled
= NULL
;
19560 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19562 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19564 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19567 /* Avoid demangling DW_STRING (attr) the second time on a second
19568 call for the same DIE. */
19569 if (!DW_STRING_IS_CANONICAL (attr
))
19570 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
19576 /* FIXME: we already did this for the partial symbol... */
19578 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19579 demangled
, strlen (demangled
));
19580 DW_STRING_IS_CANONICAL (attr
) = 1;
19583 /* Strip any leading namespaces/classes, keep only the base name.
19584 DW_AT_name for named DIEs does not contain the prefixes. */
19585 base
= strrchr (DW_STRING (attr
), ':');
19586 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
19589 return DW_STRING (attr
);
19598 if (!DW_STRING_IS_CANONICAL (attr
))
19601 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
19602 &cu
->objfile
->per_bfd
->storage_obstack
);
19603 DW_STRING_IS_CANONICAL (attr
) = 1;
19605 return DW_STRING (attr
);
19608 /* Return the die that this die in an extension of, or NULL if there
19609 is none. *EXT_CU is the CU containing DIE on input, and the CU
19610 containing the return value on output. */
19612 static struct die_info
*
19613 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
19615 struct attribute
*attr
;
19617 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
19621 return follow_die_ref (die
, attr
, ext_cu
);
19624 /* Convert a DIE tag into its string name. */
19626 static const char *
19627 dwarf_tag_name (unsigned tag
)
19629 const char *name
= get_DW_TAG_name (tag
);
19632 return "DW_TAG_<unknown>";
19637 /* Convert a DWARF attribute code into its string name. */
19639 static const char *
19640 dwarf_attr_name (unsigned attr
)
19644 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19645 if (attr
== DW_AT_MIPS_fde
)
19646 return "DW_AT_MIPS_fde";
19648 if (attr
== DW_AT_HP_block_index
)
19649 return "DW_AT_HP_block_index";
19652 name
= get_DW_AT_name (attr
);
19655 return "DW_AT_<unknown>";
19660 /* Convert a DWARF value form code into its string name. */
19662 static const char *
19663 dwarf_form_name (unsigned form
)
19665 const char *name
= get_DW_FORM_name (form
);
19668 return "DW_FORM_<unknown>";
19674 dwarf_bool_name (unsigned mybool
)
19682 /* Convert a DWARF type code into its string name. */
19684 static const char *
19685 dwarf_type_encoding_name (unsigned enc
)
19687 const char *name
= get_DW_ATE_name (enc
);
19690 return "DW_ATE_<unknown>";
19696 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
19700 print_spaces (indent
, f
);
19701 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
19702 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
19704 if (die
->parent
!= NULL
)
19706 print_spaces (indent
, f
);
19707 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
19708 die
->parent
->offset
.sect_off
);
19711 print_spaces (indent
, f
);
19712 fprintf_unfiltered (f
, " has children: %s\n",
19713 dwarf_bool_name (die
->child
!= NULL
));
19715 print_spaces (indent
, f
);
19716 fprintf_unfiltered (f
, " attributes:\n");
19718 for (i
= 0; i
< die
->num_attrs
; ++i
)
19720 print_spaces (indent
, f
);
19721 fprintf_unfiltered (f
, " %s (%s) ",
19722 dwarf_attr_name (die
->attrs
[i
].name
),
19723 dwarf_form_name (die
->attrs
[i
].form
));
19725 switch (die
->attrs
[i
].form
)
19728 case DW_FORM_GNU_addr_index
:
19729 fprintf_unfiltered (f
, "address: ");
19730 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
19732 case DW_FORM_block2
:
19733 case DW_FORM_block4
:
19734 case DW_FORM_block
:
19735 case DW_FORM_block1
:
19736 fprintf_unfiltered (f
, "block: size %s",
19737 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19739 case DW_FORM_exprloc
:
19740 fprintf_unfiltered (f
, "expression: size %s",
19741 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19743 case DW_FORM_ref_addr
:
19744 fprintf_unfiltered (f
, "ref address: ");
19745 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19747 case DW_FORM_GNU_ref_alt
:
19748 fprintf_unfiltered (f
, "alt ref address: ");
19749 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19755 case DW_FORM_ref_udata
:
19756 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
19757 (long) (DW_UNSND (&die
->attrs
[i
])));
19759 case DW_FORM_data1
:
19760 case DW_FORM_data2
:
19761 case DW_FORM_data4
:
19762 case DW_FORM_data8
:
19763 case DW_FORM_udata
:
19764 case DW_FORM_sdata
:
19765 fprintf_unfiltered (f
, "constant: %s",
19766 pulongest (DW_UNSND (&die
->attrs
[i
])));
19768 case DW_FORM_sec_offset
:
19769 fprintf_unfiltered (f
, "section offset: %s",
19770 pulongest (DW_UNSND (&die
->attrs
[i
])));
19772 case DW_FORM_ref_sig8
:
19773 fprintf_unfiltered (f
, "signature: %s",
19774 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
19776 case DW_FORM_string
:
19778 case DW_FORM_GNU_str_index
:
19779 case DW_FORM_GNU_strp_alt
:
19780 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
19781 DW_STRING (&die
->attrs
[i
])
19782 ? DW_STRING (&die
->attrs
[i
]) : "",
19783 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
19786 if (DW_UNSND (&die
->attrs
[i
]))
19787 fprintf_unfiltered (f
, "flag: TRUE");
19789 fprintf_unfiltered (f
, "flag: FALSE");
19791 case DW_FORM_flag_present
:
19792 fprintf_unfiltered (f
, "flag: TRUE");
19794 case DW_FORM_indirect
:
19795 /* The reader will have reduced the indirect form to
19796 the "base form" so this form should not occur. */
19797 fprintf_unfiltered (f
,
19798 "unexpected attribute form: DW_FORM_indirect");
19801 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
19802 die
->attrs
[i
].form
);
19805 fprintf_unfiltered (f
, "\n");
19810 dump_die_for_error (struct die_info
*die
)
19812 dump_die_shallow (gdb_stderr
, 0, die
);
19816 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
19818 int indent
= level
* 4;
19820 gdb_assert (die
!= NULL
);
19822 if (level
>= max_level
)
19825 dump_die_shallow (f
, indent
, die
);
19827 if (die
->child
!= NULL
)
19829 print_spaces (indent
, f
);
19830 fprintf_unfiltered (f
, " Children:");
19831 if (level
+ 1 < max_level
)
19833 fprintf_unfiltered (f
, "\n");
19834 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
19838 fprintf_unfiltered (f
,
19839 " [not printed, max nesting level reached]\n");
19843 if (die
->sibling
!= NULL
&& level
> 0)
19845 dump_die_1 (f
, level
, max_level
, die
->sibling
);
19849 /* This is called from the pdie macro in gdbinit.in.
19850 It's not static so gcc will keep a copy callable from gdb. */
19853 dump_die (struct die_info
*die
, int max_level
)
19855 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
19859 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
19863 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
19869 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19873 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
19875 sect_offset retval
= { DW_UNSND (attr
) };
19877 if (attr_form_is_ref (attr
))
19880 retval
.sect_off
= 0;
19881 complaint (&symfile_complaints
,
19882 _("unsupported die ref attribute form: '%s'"),
19883 dwarf_form_name (attr
->form
));
19887 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19888 * the value held by the attribute is not constant. */
19891 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
19893 if (attr
->form
== DW_FORM_sdata
)
19894 return DW_SND (attr
);
19895 else if (attr
->form
== DW_FORM_udata
19896 || attr
->form
== DW_FORM_data1
19897 || attr
->form
== DW_FORM_data2
19898 || attr
->form
== DW_FORM_data4
19899 || attr
->form
== DW_FORM_data8
)
19900 return DW_UNSND (attr
);
19903 complaint (&symfile_complaints
,
19904 _("Attribute value is not a constant (%s)"),
19905 dwarf_form_name (attr
->form
));
19906 return default_value
;
19910 /* Follow reference or signature attribute ATTR of SRC_DIE.
19911 On entry *REF_CU is the CU of SRC_DIE.
19912 On exit *REF_CU is the CU of the result. */
19914 static struct die_info
*
19915 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
19916 struct dwarf2_cu
**ref_cu
)
19918 struct die_info
*die
;
19920 if (attr_form_is_ref (attr
))
19921 die
= follow_die_ref (src_die
, attr
, ref_cu
);
19922 else if (attr
->form
== DW_FORM_ref_sig8
)
19923 die
= follow_die_sig (src_die
, attr
, ref_cu
);
19926 dump_die_for_error (src_die
);
19927 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19928 objfile_name ((*ref_cu
)->objfile
));
19934 /* Follow reference OFFSET.
19935 On entry *REF_CU is the CU of the source die referencing OFFSET.
19936 On exit *REF_CU is the CU of the result.
19937 Returns NULL if OFFSET is invalid. */
19939 static struct die_info
*
19940 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
19941 struct dwarf2_cu
**ref_cu
)
19943 struct die_info temp_die
;
19944 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
19946 gdb_assert (cu
->per_cu
!= NULL
);
19950 if (cu
->per_cu
->is_debug_types
)
19952 /* .debug_types CUs cannot reference anything outside their CU.
19953 If they need to, they have to reference a signatured type via
19954 DW_FORM_ref_sig8. */
19955 if (! offset_in_cu_p (&cu
->header
, offset
))
19958 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
19959 || ! offset_in_cu_p (&cu
->header
, offset
))
19961 struct dwarf2_per_cu_data
*per_cu
;
19963 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
19966 /* If necessary, add it to the queue and load its DIEs. */
19967 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
19968 load_full_comp_unit (per_cu
, cu
->language
);
19970 target_cu
= per_cu
->cu
;
19972 else if (cu
->dies
== NULL
)
19974 /* We're loading full DIEs during partial symbol reading. */
19975 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
19976 load_full_comp_unit (cu
->per_cu
, language_minimal
);
19979 *ref_cu
= target_cu
;
19980 temp_die
.offset
= offset
;
19981 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
19984 /* Follow reference attribute ATTR of SRC_DIE.
19985 On entry *REF_CU is the CU of SRC_DIE.
19986 On exit *REF_CU is the CU of the result. */
19988 static struct die_info
*
19989 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
19990 struct dwarf2_cu
**ref_cu
)
19992 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
19993 struct dwarf2_cu
*cu
= *ref_cu
;
19994 struct die_info
*die
;
19996 die
= follow_die_offset (offset
,
19997 (attr
->form
== DW_FORM_GNU_ref_alt
19998 || cu
->per_cu
->is_dwz
),
20001 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
20002 "at 0x%x [in module %s]"),
20003 offset
.sect_off
, src_die
->offset
.sect_off
,
20004 objfile_name (cu
->objfile
));
20009 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
20010 Returned value is intended for DW_OP_call*. Returned
20011 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
20013 struct dwarf2_locexpr_baton
20014 dwarf2_fetch_die_loc_sect_off (sect_offset offset
,
20015 struct dwarf2_per_cu_data
*per_cu
,
20016 CORE_ADDR (*get_frame_pc
) (void *baton
),
20019 struct dwarf2_cu
*cu
;
20020 struct die_info
*die
;
20021 struct attribute
*attr
;
20022 struct dwarf2_locexpr_baton retval
;
20024 dw2_setup (per_cu
->objfile
);
20026 if (per_cu
->cu
== NULL
)
20031 /* We shouldn't get here for a dummy CU, but don't crash on the user.
20032 Instead just throw an error, not much else we can do. */
20033 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
20034 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20037 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20039 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20040 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20042 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20045 /* DWARF: "If there is no such attribute, then there is no effect.".
20046 DATA is ignored if SIZE is 0. */
20048 retval
.data
= NULL
;
20051 else if (attr_form_is_section_offset (attr
))
20053 struct dwarf2_loclist_baton loclist_baton
;
20054 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
20057 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
20059 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
20061 retval
.size
= size
;
20065 if (!attr_form_is_block (attr
))
20066 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
20067 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
20068 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20070 retval
.data
= DW_BLOCK (attr
)->data
;
20071 retval
.size
= DW_BLOCK (attr
)->size
;
20073 retval
.per_cu
= cu
->per_cu
;
20075 age_cached_comp_units ();
20080 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
20083 struct dwarf2_locexpr_baton
20084 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
20085 struct dwarf2_per_cu_data
*per_cu
,
20086 CORE_ADDR (*get_frame_pc
) (void *baton
),
20089 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
20091 return dwarf2_fetch_die_loc_sect_off (offset
, per_cu
, get_frame_pc
, baton
);
20094 /* Write a constant of a given type as target-ordered bytes into
20097 static const gdb_byte
*
20098 write_constant_as_bytes (struct obstack
*obstack
,
20099 enum bfd_endian byte_order
,
20106 *len
= TYPE_LENGTH (type
);
20107 result
= obstack_alloc (obstack
, *len
);
20108 store_unsigned_integer (result
, *len
, byte_order
, value
);
20113 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
20114 pointer to the constant bytes and set LEN to the length of the
20115 data. If memory is needed, allocate it on OBSTACK. If the DIE
20116 does not have a DW_AT_const_value, return NULL. */
20119 dwarf2_fetch_constant_bytes (sect_offset offset
,
20120 struct dwarf2_per_cu_data
*per_cu
,
20121 struct obstack
*obstack
,
20124 struct dwarf2_cu
*cu
;
20125 struct die_info
*die
;
20126 struct attribute
*attr
;
20127 const gdb_byte
*result
= NULL
;
20130 enum bfd_endian byte_order
;
20132 dw2_setup (per_cu
->objfile
);
20134 if (per_cu
->cu
== NULL
)
20139 /* We shouldn't get here for a dummy CU, but don't crash on the user.
20140 Instead just throw an error, not much else we can do. */
20141 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
20142 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20145 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20147 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20148 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20151 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20155 byte_order
= (bfd_big_endian (per_cu
->objfile
->obfd
)
20156 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
20158 switch (attr
->form
)
20161 case DW_FORM_GNU_addr_index
:
20165 *len
= cu
->header
.addr_size
;
20166 tem
= obstack_alloc (obstack
, *len
);
20167 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
20171 case DW_FORM_string
:
20173 case DW_FORM_GNU_str_index
:
20174 case DW_FORM_GNU_strp_alt
:
20175 /* DW_STRING is already allocated on the objfile obstack, point
20177 result
= (const gdb_byte
*) DW_STRING (attr
);
20178 *len
= strlen (DW_STRING (attr
));
20180 case DW_FORM_block1
:
20181 case DW_FORM_block2
:
20182 case DW_FORM_block4
:
20183 case DW_FORM_block
:
20184 case DW_FORM_exprloc
:
20185 result
= DW_BLOCK (attr
)->data
;
20186 *len
= DW_BLOCK (attr
)->size
;
20189 /* The DW_AT_const_value attributes are supposed to carry the
20190 symbol's value "represented as it would be on the target
20191 architecture." By the time we get here, it's already been
20192 converted to host endianness, so we just need to sign- or
20193 zero-extend it as appropriate. */
20194 case DW_FORM_data1
:
20195 type
= die_type (die
, cu
);
20196 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
20197 if (result
== NULL
)
20198 result
= write_constant_as_bytes (obstack
, byte_order
,
20201 case DW_FORM_data2
:
20202 type
= die_type (die
, cu
);
20203 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
20204 if (result
== NULL
)
20205 result
= write_constant_as_bytes (obstack
, byte_order
,
20208 case DW_FORM_data4
:
20209 type
= die_type (die
, cu
);
20210 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
20211 if (result
== NULL
)
20212 result
= write_constant_as_bytes (obstack
, byte_order
,
20215 case DW_FORM_data8
:
20216 type
= die_type (die
, cu
);
20217 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
20218 if (result
== NULL
)
20219 result
= write_constant_as_bytes (obstack
, byte_order
,
20223 case DW_FORM_sdata
:
20224 type
= die_type (die
, cu
);
20225 result
= write_constant_as_bytes (obstack
, byte_order
,
20226 type
, DW_SND (attr
), len
);
20229 case DW_FORM_udata
:
20230 type
= die_type (die
, cu
);
20231 result
= write_constant_as_bytes (obstack
, byte_order
,
20232 type
, DW_UNSND (attr
), len
);
20236 complaint (&symfile_complaints
,
20237 _("unsupported const value attribute form: '%s'"),
20238 dwarf_form_name (attr
->form
));
20245 /* Return the type of the DIE at DIE_OFFSET in the CU named by
20249 dwarf2_get_die_type (cu_offset die_offset
,
20250 struct dwarf2_per_cu_data
*per_cu
)
20252 sect_offset die_offset_sect
;
20254 dw2_setup (per_cu
->objfile
);
20256 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
20257 return get_die_type_at_offset (die_offset_sect
, per_cu
);
20260 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
20261 On entry *REF_CU is the CU of SRC_DIE.
20262 On exit *REF_CU is the CU of the result.
20263 Returns NULL if the referenced DIE isn't found. */
20265 static struct die_info
*
20266 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
20267 struct dwarf2_cu
**ref_cu
)
20269 struct objfile
*objfile
= (*ref_cu
)->objfile
;
20270 struct die_info temp_die
;
20271 struct dwarf2_cu
*sig_cu
;
20272 struct die_info
*die
;
20274 /* While it might be nice to assert sig_type->type == NULL here,
20275 we can get here for DW_AT_imported_declaration where we need
20276 the DIE not the type. */
20278 /* If necessary, add it to the queue and load its DIEs. */
20280 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
20281 read_signatured_type (sig_type
);
20283 sig_cu
= sig_type
->per_cu
.cu
;
20284 gdb_assert (sig_cu
!= NULL
);
20285 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
20286 temp_die
.offset
= sig_type
->type_offset_in_section
;
20287 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
20288 temp_die
.offset
.sect_off
);
20291 /* For .gdb_index version 7 keep track of included TUs.
20292 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
20293 if (dwarf2_per_objfile
->index_table
!= NULL
20294 && dwarf2_per_objfile
->index_table
->version
<= 7)
20296 VEC_safe_push (dwarf2_per_cu_ptr
,
20297 (*ref_cu
)->per_cu
->imported_symtabs
,
20308 /* Follow signatured type referenced by ATTR in SRC_DIE.
20309 On entry *REF_CU is the CU of SRC_DIE.
20310 On exit *REF_CU is the CU of the result.
20311 The result is the DIE of the type.
20312 If the referenced type cannot be found an error is thrown. */
20314 static struct die_info
*
20315 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
20316 struct dwarf2_cu
**ref_cu
)
20318 ULONGEST signature
= DW_SIGNATURE (attr
);
20319 struct signatured_type
*sig_type
;
20320 struct die_info
*die
;
20322 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
20324 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
20325 /* sig_type will be NULL if the signatured type is missing from
20327 if (sig_type
== NULL
)
20329 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
20330 " from DIE at 0x%x [in module %s]"),
20331 hex_string (signature
), src_die
->offset
.sect_off
,
20332 objfile_name ((*ref_cu
)->objfile
));
20335 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
20338 dump_die_for_error (src_die
);
20339 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
20340 " from DIE at 0x%x [in module %s]"),
20341 hex_string (signature
), src_die
->offset
.sect_off
,
20342 objfile_name ((*ref_cu
)->objfile
));
20348 /* Get the type specified by SIGNATURE referenced in DIE/CU,
20349 reading in and processing the type unit if necessary. */
20351 static struct type
*
20352 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
20353 struct dwarf2_cu
*cu
)
20355 struct signatured_type
*sig_type
;
20356 struct dwarf2_cu
*type_cu
;
20357 struct die_info
*type_die
;
20360 sig_type
= lookup_signatured_type (cu
, signature
);
20361 /* sig_type will be NULL if the signatured type is missing from
20363 if (sig_type
== NULL
)
20365 complaint (&symfile_complaints
,
20366 _("Dwarf Error: Cannot find signatured DIE %s referenced"
20367 " from DIE at 0x%x [in module %s]"),
20368 hex_string (signature
), die
->offset
.sect_off
,
20369 objfile_name (dwarf2_per_objfile
->objfile
));
20370 return build_error_marker_type (cu
, die
);
20373 /* If we already know the type we're done. */
20374 if (sig_type
->type
!= NULL
)
20375 return sig_type
->type
;
20378 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
20379 if (type_die
!= NULL
)
20381 /* N.B. We need to call get_die_type to ensure only one type for this DIE
20382 is created. This is important, for example, because for c++ classes
20383 we need TYPE_NAME set which is only done by new_symbol. Blech. */
20384 type
= read_type_die (type_die
, type_cu
);
20387 complaint (&symfile_complaints
,
20388 _("Dwarf Error: Cannot build signatured type %s"
20389 " referenced from DIE at 0x%x [in module %s]"),
20390 hex_string (signature
), die
->offset
.sect_off
,
20391 objfile_name (dwarf2_per_objfile
->objfile
));
20392 type
= build_error_marker_type (cu
, die
);
20397 complaint (&symfile_complaints
,
20398 _("Dwarf Error: Problem reading signatured DIE %s referenced"
20399 " from DIE at 0x%x [in module %s]"),
20400 hex_string (signature
), die
->offset
.sect_off
,
20401 objfile_name (dwarf2_per_objfile
->objfile
));
20402 type
= build_error_marker_type (cu
, die
);
20404 sig_type
->type
= type
;
20409 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
20410 reading in and processing the type unit if necessary. */
20412 static struct type
*
20413 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
20414 struct dwarf2_cu
*cu
) /* ARI: editCase function */
20416 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
20417 if (attr_form_is_ref (attr
))
20419 struct dwarf2_cu
*type_cu
= cu
;
20420 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
20422 return read_type_die (type_die
, type_cu
);
20424 else if (attr
->form
== DW_FORM_ref_sig8
)
20426 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
20430 complaint (&symfile_complaints
,
20431 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
20432 " at 0x%x [in module %s]"),
20433 dwarf_form_name (attr
->form
), die
->offset
.sect_off
,
20434 objfile_name (dwarf2_per_objfile
->objfile
));
20435 return build_error_marker_type (cu
, die
);
20439 /* Load the DIEs associated with type unit PER_CU into memory. */
20442 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
20444 struct signatured_type
*sig_type
;
20446 /* Caller is responsible for ensuring type_unit_groups don't get here. */
20447 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
20449 /* We have the per_cu, but we need the signatured_type.
20450 Fortunately this is an easy translation. */
20451 gdb_assert (per_cu
->is_debug_types
);
20452 sig_type
= (struct signatured_type
*) per_cu
;
20454 gdb_assert (per_cu
->cu
== NULL
);
20456 read_signatured_type (sig_type
);
20458 gdb_assert (per_cu
->cu
!= NULL
);
20461 /* die_reader_func for read_signatured_type.
20462 This is identical to load_full_comp_unit_reader,
20463 but is kept separate for now. */
20466 read_signatured_type_reader (const struct die_reader_specs
*reader
,
20467 const gdb_byte
*info_ptr
,
20468 struct die_info
*comp_unit_die
,
20472 struct dwarf2_cu
*cu
= reader
->cu
;
20474 gdb_assert (cu
->die_hash
== NULL
);
20476 htab_create_alloc_ex (cu
->header
.length
/ 12,
20480 &cu
->comp_unit_obstack
,
20481 hashtab_obstack_allocate
,
20482 dummy_obstack_deallocate
);
20485 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
20486 &info_ptr
, comp_unit_die
);
20487 cu
->dies
= comp_unit_die
;
20488 /* comp_unit_die is not stored in die_hash, no need. */
20490 /* We try not to read any attributes in this function, because not
20491 all CUs needed for references have been loaded yet, and symbol
20492 table processing isn't initialized. But we have to set the CU language,
20493 or we won't be able to build types correctly.
20494 Similarly, if we do not read the producer, we can not apply
20495 producer-specific interpretation. */
20496 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
20499 /* Read in a signatured type and build its CU and DIEs.
20500 If the type is a stub for the real type in a DWO file,
20501 read in the real type from the DWO file as well. */
20504 read_signatured_type (struct signatured_type
*sig_type
)
20506 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
20508 gdb_assert (per_cu
->is_debug_types
);
20509 gdb_assert (per_cu
->cu
== NULL
);
20511 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
20512 read_signatured_type_reader
, NULL
);
20513 sig_type
->per_cu
.tu_read
= 1;
20516 /* Decode simple location descriptions.
20517 Given a pointer to a dwarf block that defines a location, compute
20518 the location and return the value.
20520 NOTE drow/2003-11-18: This function is called in two situations
20521 now: for the address of static or global variables (partial symbols
20522 only) and for offsets into structures which are expected to be
20523 (more or less) constant. The partial symbol case should go away,
20524 and only the constant case should remain. That will let this
20525 function complain more accurately. A few special modes are allowed
20526 without complaint for global variables (for instance, global
20527 register values and thread-local values).
20529 A location description containing no operations indicates that the
20530 object is optimized out. The return value is 0 for that case.
20531 FIXME drow/2003-11-16: No callers check for this case any more; soon all
20532 callers will only want a very basic result and this can become a
20535 Note that stack[0] is unused except as a default error return. */
20538 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
20540 struct objfile
*objfile
= cu
->objfile
;
20542 size_t size
= blk
->size
;
20543 const gdb_byte
*data
= blk
->data
;
20544 CORE_ADDR stack
[64];
20546 unsigned int bytes_read
, unsnd
;
20552 stack
[++stacki
] = 0;
20591 stack
[++stacki
] = op
- DW_OP_lit0
;
20626 stack
[++stacki
] = op
- DW_OP_reg0
;
20628 dwarf2_complex_location_expr_complaint ();
20632 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
20634 stack
[++stacki
] = unsnd
;
20636 dwarf2_complex_location_expr_complaint ();
20640 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
20645 case DW_OP_const1u
:
20646 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
20650 case DW_OP_const1s
:
20651 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
20655 case DW_OP_const2u
:
20656 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
20660 case DW_OP_const2s
:
20661 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
20665 case DW_OP_const4u
:
20666 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
20670 case DW_OP_const4s
:
20671 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
20675 case DW_OP_const8u
:
20676 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
20681 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
20687 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
20692 stack
[stacki
+ 1] = stack
[stacki
];
20697 stack
[stacki
- 1] += stack
[stacki
];
20701 case DW_OP_plus_uconst
:
20702 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
20708 stack
[stacki
- 1] -= stack
[stacki
];
20713 /* If we're not the last op, then we definitely can't encode
20714 this using GDB's address_class enum. This is valid for partial
20715 global symbols, although the variable's address will be bogus
20718 dwarf2_complex_location_expr_complaint ();
20721 case DW_OP_GNU_push_tls_address
:
20722 /* The top of the stack has the offset from the beginning
20723 of the thread control block at which the variable is located. */
20724 /* Nothing should follow this operator, so the top of stack would
20726 /* This is valid for partial global symbols, but the variable's
20727 address will be bogus in the psymtab. Make it always at least
20728 non-zero to not look as a variable garbage collected by linker
20729 which have DW_OP_addr 0. */
20731 dwarf2_complex_location_expr_complaint ();
20735 case DW_OP_GNU_uninit
:
20738 case DW_OP_GNU_addr_index
:
20739 case DW_OP_GNU_const_index
:
20740 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
20747 const char *name
= get_DW_OP_name (op
);
20750 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
20753 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
20757 return (stack
[stacki
]);
20760 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20761 outside of the allocated space. Also enforce minimum>0. */
20762 if (stacki
>= ARRAY_SIZE (stack
) - 1)
20764 complaint (&symfile_complaints
,
20765 _("location description stack overflow"));
20771 complaint (&symfile_complaints
,
20772 _("location description stack underflow"));
20776 return (stack
[stacki
]);
20779 /* memory allocation interface */
20781 static struct dwarf_block
*
20782 dwarf_alloc_block (struct dwarf2_cu
*cu
)
20784 struct dwarf_block
*blk
;
20786 blk
= (struct dwarf_block
*)
20787 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
20791 static struct die_info
*
20792 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
20794 struct die_info
*die
;
20795 size_t size
= sizeof (struct die_info
);
20798 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
20800 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
20801 memset (die
, 0, sizeof (struct die_info
));
20806 /* Macro support. */
20808 /* Return file name relative to the compilation directory of file number I in
20809 *LH's file name table. The result is allocated using xmalloc; the caller is
20810 responsible for freeing it. */
20813 file_file_name (int file
, struct line_header
*lh
)
20815 /* Is the file number a valid index into the line header's file name
20816 table? Remember that file numbers start with one, not zero. */
20817 if (1 <= file
&& file
<= lh
->num_file_names
)
20819 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
20821 if (IS_ABSOLUTE_PATH (fe
->name
) || fe
->dir_index
== 0
20822 || lh
->include_dirs
== NULL
)
20823 return xstrdup (fe
->name
);
20824 return concat (lh
->include_dirs
[fe
->dir_index
- 1], SLASH_STRING
,
20829 /* The compiler produced a bogus file number. We can at least
20830 record the macro definitions made in the file, even if we
20831 won't be able to find the file by name. */
20832 char fake_name
[80];
20834 xsnprintf (fake_name
, sizeof (fake_name
),
20835 "<bad macro file number %d>", file
);
20837 complaint (&symfile_complaints
,
20838 _("bad file number in macro information (%d)"),
20841 return xstrdup (fake_name
);
20845 /* Return the full name of file number I in *LH's file name table.
20846 Use COMP_DIR as the name of the current directory of the
20847 compilation. The result is allocated using xmalloc; the caller is
20848 responsible for freeing it. */
20850 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
20852 /* Is the file number a valid index into the line header's file name
20853 table? Remember that file numbers start with one, not zero. */
20854 if (1 <= file
&& file
<= lh
->num_file_names
)
20856 char *relative
= file_file_name (file
, lh
);
20858 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
20860 return reconcat (relative
, comp_dir
, SLASH_STRING
, relative
, NULL
);
20863 return file_file_name (file
, lh
);
20867 static struct macro_source_file
*
20868 macro_start_file (int file
, int line
,
20869 struct macro_source_file
*current_file
,
20870 struct line_header
*lh
)
20872 /* File name relative to the compilation directory of this source file. */
20873 char *file_name
= file_file_name (file
, lh
);
20875 if (! current_file
)
20877 /* Note: We don't create a macro table for this compilation unit
20878 at all until we actually get a filename. */
20879 struct macro_table
*macro_table
= get_macro_table ();
20881 /* If we have no current file, then this must be the start_file
20882 directive for the compilation unit's main source file. */
20883 current_file
= macro_set_main (macro_table
, file_name
);
20884 macro_define_special (macro_table
);
20887 current_file
= macro_include (current_file
, line
, file_name
);
20891 return current_file
;
20895 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20896 followed by a null byte. */
20898 copy_string (const char *buf
, int len
)
20900 char *s
= xmalloc (len
+ 1);
20902 memcpy (s
, buf
, len
);
20908 static const char *
20909 consume_improper_spaces (const char *p
, const char *body
)
20913 complaint (&symfile_complaints
,
20914 _("macro definition contains spaces "
20915 "in formal argument list:\n`%s'"),
20927 parse_macro_definition (struct macro_source_file
*file
, int line
,
20932 /* The body string takes one of two forms. For object-like macro
20933 definitions, it should be:
20935 <macro name> " " <definition>
20937 For function-like macro definitions, it should be:
20939 <macro name> "() " <definition>
20941 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20943 Spaces may appear only where explicitly indicated, and in the
20946 The Dwarf 2 spec says that an object-like macro's name is always
20947 followed by a space, but versions of GCC around March 2002 omit
20948 the space when the macro's definition is the empty string.
20950 The Dwarf 2 spec says that there should be no spaces between the
20951 formal arguments in a function-like macro's formal argument list,
20952 but versions of GCC around March 2002 include spaces after the
20956 /* Find the extent of the macro name. The macro name is terminated
20957 by either a space or null character (for an object-like macro) or
20958 an opening paren (for a function-like macro). */
20959 for (p
= body
; *p
; p
++)
20960 if (*p
== ' ' || *p
== '(')
20963 if (*p
== ' ' || *p
== '\0')
20965 /* It's an object-like macro. */
20966 int name_len
= p
- body
;
20967 char *name
= copy_string (body
, name_len
);
20968 const char *replacement
;
20971 replacement
= body
+ name_len
+ 1;
20974 dwarf2_macro_malformed_definition_complaint (body
);
20975 replacement
= body
+ name_len
;
20978 macro_define_object (file
, line
, name
, replacement
);
20982 else if (*p
== '(')
20984 /* It's a function-like macro. */
20985 char *name
= copy_string (body
, p
- body
);
20988 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
20992 p
= consume_improper_spaces (p
, body
);
20994 /* Parse the formal argument list. */
20995 while (*p
&& *p
!= ')')
20997 /* Find the extent of the current argument name. */
20998 const char *arg_start
= p
;
21000 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
21003 if (! *p
|| p
== arg_start
)
21004 dwarf2_macro_malformed_definition_complaint (body
);
21007 /* Make sure argv has room for the new argument. */
21008 if (argc
>= argv_size
)
21011 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
21014 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
21017 p
= consume_improper_spaces (p
, body
);
21019 /* Consume the comma, if present. */
21024 p
= consume_improper_spaces (p
, body
);
21033 /* Perfectly formed definition, no complaints. */
21034 macro_define_function (file
, line
, name
,
21035 argc
, (const char **) argv
,
21037 else if (*p
== '\0')
21039 /* Complain, but do define it. */
21040 dwarf2_macro_malformed_definition_complaint (body
);
21041 macro_define_function (file
, line
, name
,
21042 argc
, (const char **) argv
,
21046 /* Just complain. */
21047 dwarf2_macro_malformed_definition_complaint (body
);
21050 /* Just complain. */
21051 dwarf2_macro_malformed_definition_complaint (body
);
21057 for (i
= 0; i
< argc
; i
++)
21063 dwarf2_macro_malformed_definition_complaint (body
);
21066 /* Skip some bytes from BYTES according to the form given in FORM.
21067 Returns the new pointer. */
21069 static const gdb_byte
*
21070 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
21071 enum dwarf_form form
,
21072 unsigned int offset_size
,
21073 struct dwarf2_section_info
*section
)
21075 unsigned int bytes_read
;
21079 case DW_FORM_data1
:
21084 case DW_FORM_data2
:
21088 case DW_FORM_data4
:
21092 case DW_FORM_data8
:
21096 case DW_FORM_string
:
21097 read_direct_string (abfd
, bytes
, &bytes_read
);
21098 bytes
+= bytes_read
;
21101 case DW_FORM_sec_offset
:
21103 case DW_FORM_GNU_strp_alt
:
21104 bytes
+= offset_size
;
21107 case DW_FORM_block
:
21108 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
21109 bytes
+= bytes_read
;
21112 case DW_FORM_block1
:
21113 bytes
+= 1 + read_1_byte (abfd
, bytes
);
21115 case DW_FORM_block2
:
21116 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
21118 case DW_FORM_block4
:
21119 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
21122 case DW_FORM_sdata
:
21123 case DW_FORM_udata
:
21124 case DW_FORM_GNU_addr_index
:
21125 case DW_FORM_GNU_str_index
:
21126 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
21129 dwarf2_section_buffer_overflow_complaint (section
);
21137 complaint (&symfile_complaints
,
21138 _("invalid form 0x%x in `%s'"),
21139 form
, get_section_name (section
));
21147 /* A helper for dwarf_decode_macros that handles skipping an unknown
21148 opcode. Returns an updated pointer to the macro data buffer; or,
21149 on error, issues a complaint and returns NULL. */
21151 static const gdb_byte
*
21152 skip_unknown_opcode (unsigned int opcode
,
21153 const gdb_byte
**opcode_definitions
,
21154 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21156 unsigned int offset_size
,
21157 struct dwarf2_section_info
*section
)
21159 unsigned int bytes_read
, i
;
21161 const gdb_byte
*defn
;
21163 if (opcode_definitions
[opcode
] == NULL
)
21165 complaint (&symfile_complaints
,
21166 _("unrecognized DW_MACFINO opcode 0x%x"),
21171 defn
= opcode_definitions
[opcode
];
21172 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
21173 defn
+= bytes_read
;
21175 for (i
= 0; i
< arg
; ++i
)
21177 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
21178 (enum dwarf_form
) defn
[i
], offset_size
,
21180 if (mac_ptr
== NULL
)
21182 /* skip_form_bytes already issued the complaint. */
21190 /* A helper function which parses the header of a macro section.
21191 If the macro section is the extended (for now called "GNU") type,
21192 then this updates *OFFSET_SIZE. Returns a pointer to just after
21193 the header, or issues a complaint and returns NULL on error. */
21195 static const gdb_byte
*
21196 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
21198 const gdb_byte
*mac_ptr
,
21199 unsigned int *offset_size
,
21200 int section_is_gnu
)
21202 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
21204 if (section_is_gnu
)
21206 unsigned int version
, flags
;
21208 version
= read_2_bytes (abfd
, mac_ptr
);
21211 complaint (&symfile_complaints
,
21212 _("unrecognized version `%d' in .debug_macro section"),
21218 flags
= read_1_byte (abfd
, mac_ptr
);
21220 *offset_size
= (flags
& 1) ? 8 : 4;
21222 if ((flags
& 2) != 0)
21223 /* We don't need the line table offset. */
21224 mac_ptr
+= *offset_size
;
21226 /* Vendor opcode descriptions. */
21227 if ((flags
& 4) != 0)
21229 unsigned int i
, count
;
21231 count
= read_1_byte (abfd
, mac_ptr
);
21233 for (i
= 0; i
< count
; ++i
)
21235 unsigned int opcode
, bytes_read
;
21238 opcode
= read_1_byte (abfd
, mac_ptr
);
21240 opcode_definitions
[opcode
] = mac_ptr
;
21241 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21242 mac_ptr
+= bytes_read
;
21251 /* A helper for dwarf_decode_macros that handles the GNU extensions,
21252 including DW_MACRO_GNU_transparent_include. */
21255 dwarf_decode_macro_bytes (bfd
*abfd
,
21256 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21257 struct macro_source_file
*current_file
,
21258 struct line_header
*lh
,
21259 struct dwarf2_section_info
*section
,
21260 int section_is_gnu
, int section_is_dwz
,
21261 unsigned int offset_size
,
21262 htab_t include_hash
)
21264 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21265 enum dwarf_macro_record_type macinfo_type
;
21266 int at_commandline
;
21267 const gdb_byte
*opcode_definitions
[256];
21269 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21270 &offset_size
, section_is_gnu
);
21271 if (mac_ptr
== NULL
)
21273 /* We already issued a complaint. */
21277 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
21278 GDB is still reading the definitions from command line. First
21279 DW_MACINFO_start_file will need to be ignored as it was already executed
21280 to create CURRENT_FILE for the main source holding also the command line
21281 definitions. On first met DW_MACINFO_start_file this flag is reset to
21282 normally execute all the remaining DW_MACINFO_start_file macinfos. */
21284 at_commandline
= 1;
21288 /* Do we at least have room for a macinfo type byte? */
21289 if (mac_ptr
>= mac_end
)
21291 dwarf2_section_buffer_overflow_complaint (section
);
21295 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
21298 /* Note that we rely on the fact that the corresponding GNU and
21299 DWARF constants are the same. */
21300 switch (macinfo_type
)
21302 /* A zero macinfo type indicates the end of the macro
21307 case DW_MACRO_GNU_define
:
21308 case DW_MACRO_GNU_undef
:
21309 case DW_MACRO_GNU_define_indirect
:
21310 case DW_MACRO_GNU_undef_indirect
:
21311 case DW_MACRO_GNU_define_indirect_alt
:
21312 case DW_MACRO_GNU_undef_indirect_alt
:
21314 unsigned int bytes_read
;
21319 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21320 mac_ptr
+= bytes_read
;
21322 if (macinfo_type
== DW_MACRO_GNU_define
21323 || macinfo_type
== DW_MACRO_GNU_undef
)
21325 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21326 mac_ptr
+= bytes_read
;
21330 LONGEST str_offset
;
21332 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21333 mac_ptr
+= offset_size
;
21335 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
21336 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
21339 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21341 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
21344 body
= read_indirect_string_at_offset (abfd
, str_offset
);
21347 is_define
= (macinfo_type
== DW_MACRO_GNU_define
21348 || macinfo_type
== DW_MACRO_GNU_define_indirect
21349 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
21350 if (! current_file
)
21352 /* DWARF violation as no main source is present. */
21353 complaint (&symfile_complaints
,
21354 _("debug info with no main source gives macro %s "
21356 is_define
? _("definition") : _("undefinition"),
21360 if ((line
== 0 && !at_commandline
)
21361 || (line
!= 0 && at_commandline
))
21362 complaint (&symfile_complaints
,
21363 _("debug info gives %s macro %s with %s line %d: %s"),
21364 at_commandline
? _("command-line") : _("in-file"),
21365 is_define
? _("definition") : _("undefinition"),
21366 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
21369 parse_macro_definition (current_file
, line
, body
);
21372 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
21373 || macinfo_type
== DW_MACRO_GNU_undef_indirect
21374 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
21375 macro_undef (current_file
, line
, body
);
21380 case DW_MACRO_GNU_start_file
:
21382 unsigned int bytes_read
;
21385 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21386 mac_ptr
+= bytes_read
;
21387 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21388 mac_ptr
+= bytes_read
;
21390 if ((line
== 0 && !at_commandline
)
21391 || (line
!= 0 && at_commandline
))
21392 complaint (&symfile_complaints
,
21393 _("debug info gives source %d included "
21394 "from %s at %s line %d"),
21395 file
, at_commandline
? _("command-line") : _("file"),
21396 line
== 0 ? _("zero") : _("non-zero"), line
);
21398 if (at_commandline
)
21400 /* This DW_MACRO_GNU_start_file was executed in the
21402 at_commandline
= 0;
21405 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21409 case DW_MACRO_GNU_end_file
:
21410 if (! current_file
)
21411 complaint (&symfile_complaints
,
21412 _("macro debug info has an unmatched "
21413 "`close_file' directive"));
21416 current_file
= current_file
->included_by
;
21417 if (! current_file
)
21419 enum dwarf_macro_record_type next_type
;
21421 /* GCC circa March 2002 doesn't produce the zero
21422 type byte marking the end of the compilation
21423 unit. Complain if it's not there, but exit no
21426 /* Do we at least have room for a macinfo type byte? */
21427 if (mac_ptr
>= mac_end
)
21429 dwarf2_section_buffer_overflow_complaint (section
);
21433 /* We don't increment mac_ptr here, so this is just
21436 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
21438 if (next_type
!= 0)
21439 complaint (&symfile_complaints
,
21440 _("no terminating 0-type entry for "
21441 "macros in `.debug_macinfo' section"));
21448 case DW_MACRO_GNU_transparent_include
:
21449 case DW_MACRO_GNU_transparent_include_alt
:
21453 bfd
*include_bfd
= abfd
;
21454 struct dwarf2_section_info
*include_section
= section
;
21455 struct dwarf2_section_info alt_section
;
21456 const gdb_byte
*include_mac_end
= mac_end
;
21457 int is_dwz
= section_is_dwz
;
21458 const gdb_byte
*new_mac_ptr
;
21460 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21461 mac_ptr
+= offset_size
;
21463 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
21465 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21467 dwarf2_read_section (objfile
, &dwz
->macro
);
21469 include_section
= &dwz
->macro
;
21470 include_bfd
= get_section_bfd_owner (include_section
);
21471 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
21475 new_mac_ptr
= include_section
->buffer
+ offset
;
21476 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
21480 /* This has actually happened; see
21481 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
21482 complaint (&symfile_complaints
,
21483 _("recursive DW_MACRO_GNU_transparent_include in "
21484 ".debug_macro section"));
21488 *slot
= (void *) new_mac_ptr
;
21490 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
21491 include_mac_end
, current_file
, lh
,
21492 section
, section_is_gnu
, is_dwz
,
21493 offset_size
, include_hash
);
21495 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
21500 case DW_MACINFO_vendor_ext
:
21501 if (!section_is_gnu
)
21503 unsigned int bytes_read
;
21506 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21507 mac_ptr
+= bytes_read
;
21508 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21509 mac_ptr
+= bytes_read
;
21511 /* We don't recognize any vendor extensions. */
21517 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21518 mac_ptr
, mac_end
, abfd
, offset_size
,
21520 if (mac_ptr
== NULL
)
21524 } while (macinfo_type
!= 0);
21528 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
21529 int section_is_gnu
)
21531 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21532 struct line_header
*lh
= cu
->line_header
;
21534 const gdb_byte
*mac_ptr
, *mac_end
;
21535 struct macro_source_file
*current_file
= 0;
21536 enum dwarf_macro_record_type macinfo_type
;
21537 unsigned int offset_size
= cu
->header
.offset_size
;
21538 const gdb_byte
*opcode_definitions
[256];
21539 struct cleanup
*cleanup
;
21540 htab_t include_hash
;
21542 struct dwarf2_section_info
*section
;
21543 const char *section_name
;
21545 if (cu
->dwo_unit
!= NULL
)
21547 if (section_is_gnu
)
21549 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
21550 section_name
= ".debug_macro.dwo";
21554 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
21555 section_name
= ".debug_macinfo.dwo";
21560 if (section_is_gnu
)
21562 section
= &dwarf2_per_objfile
->macro
;
21563 section_name
= ".debug_macro";
21567 section
= &dwarf2_per_objfile
->macinfo
;
21568 section_name
= ".debug_macinfo";
21572 dwarf2_read_section (objfile
, section
);
21573 if (section
->buffer
== NULL
)
21575 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
21578 abfd
= get_section_bfd_owner (section
);
21580 /* First pass: Find the name of the base filename.
21581 This filename is needed in order to process all macros whose definition
21582 (or undefinition) comes from the command line. These macros are defined
21583 before the first DW_MACINFO_start_file entry, and yet still need to be
21584 associated to the base file.
21586 To determine the base file name, we scan the macro definitions until we
21587 reach the first DW_MACINFO_start_file entry. We then initialize
21588 CURRENT_FILE accordingly so that any macro definition found before the
21589 first DW_MACINFO_start_file can still be associated to the base file. */
21591 mac_ptr
= section
->buffer
+ offset
;
21592 mac_end
= section
->buffer
+ section
->size
;
21594 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21595 &offset_size
, section_is_gnu
);
21596 if (mac_ptr
== NULL
)
21598 /* We already issued a complaint. */
21604 /* Do we at least have room for a macinfo type byte? */
21605 if (mac_ptr
>= mac_end
)
21607 /* Complaint is printed during the second pass as GDB will probably
21608 stop the first pass earlier upon finding
21609 DW_MACINFO_start_file. */
21613 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
21616 /* Note that we rely on the fact that the corresponding GNU and
21617 DWARF constants are the same. */
21618 switch (macinfo_type
)
21620 /* A zero macinfo type indicates the end of the macro
21625 case DW_MACRO_GNU_define
:
21626 case DW_MACRO_GNU_undef
:
21627 /* Only skip the data by MAC_PTR. */
21629 unsigned int bytes_read
;
21631 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21632 mac_ptr
+= bytes_read
;
21633 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21634 mac_ptr
+= bytes_read
;
21638 case DW_MACRO_GNU_start_file
:
21640 unsigned int bytes_read
;
21643 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21644 mac_ptr
+= bytes_read
;
21645 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21646 mac_ptr
+= bytes_read
;
21648 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21652 case DW_MACRO_GNU_end_file
:
21653 /* No data to skip by MAC_PTR. */
21656 case DW_MACRO_GNU_define_indirect
:
21657 case DW_MACRO_GNU_undef_indirect
:
21658 case DW_MACRO_GNU_define_indirect_alt
:
21659 case DW_MACRO_GNU_undef_indirect_alt
:
21661 unsigned int bytes_read
;
21663 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21664 mac_ptr
+= bytes_read
;
21665 mac_ptr
+= offset_size
;
21669 case DW_MACRO_GNU_transparent_include
:
21670 case DW_MACRO_GNU_transparent_include_alt
:
21671 /* Note that, according to the spec, a transparent include
21672 chain cannot call DW_MACRO_GNU_start_file. So, we can just
21673 skip this opcode. */
21674 mac_ptr
+= offset_size
;
21677 case DW_MACINFO_vendor_ext
:
21678 /* Only skip the data by MAC_PTR. */
21679 if (!section_is_gnu
)
21681 unsigned int bytes_read
;
21683 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21684 mac_ptr
+= bytes_read
;
21685 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21686 mac_ptr
+= bytes_read
;
21691 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21692 mac_ptr
, mac_end
, abfd
, offset_size
,
21694 if (mac_ptr
== NULL
)
21698 } while (macinfo_type
!= 0 && current_file
== NULL
);
21700 /* Second pass: Process all entries.
21702 Use the AT_COMMAND_LINE flag to determine whether we are still processing
21703 command-line macro definitions/undefinitions. This flag is unset when we
21704 reach the first DW_MACINFO_start_file entry. */
21706 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
21707 NULL
, xcalloc
, xfree
);
21708 cleanup
= make_cleanup_htab_delete (include_hash
);
21709 mac_ptr
= section
->buffer
+ offset
;
21710 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
21711 *slot
= (void *) mac_ptr
;
21712 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
21713 current_file
, lh
, section
,
21714 section_is_gnu
, 0, offset_size
, include_hash
);
21715 do_cleanups (cleanup
);
21718 /* Check if the attribute's form is a DW_FORM_block*
21719 if so return true else false. */
21722 attr_form_is_block (const struct attribute
*attr
)
21724 return (attr
== NULL
? 0 :
21725 attr
->form
== DW_FORM_block1
21726 || attr
->form
== DW_FORM_block2
21727 || attr
->form
== DW_FORM_block4
21728 || attr
->form
== DW_FORM_block
21729 || attr
->form
== DW_FORM_exprloc
);
21732 /* Return non-zero if ATTR's value is a section offset --- classes
21733 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21734 You may use DW_UNSND (attr) to retrieve such offsets.
21736 Section 7.5.4, "Attribute Encodings", explains that no attribute
21737 may have a value that belongs to more than one of these classes; it
21738 would be ambiguous if we did, because we use the same forms for all
21742 attr_form_is_section_offset (const struct attribute
*attr
)
21744 return (attr
->form
== DW_FORM_data4
21745 || attr
->form
== DW_FORM_data8
21746 || attr
->form
== DW_FORM_sec_offset
);
21749 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21750 zero otherwise. When this function returns true, you can apply
21751 dwarf2_get_attr_constant_value to it.
21753 However, note that for some attributes you must check
21754 attr_form_is_section_offset before using this test. DW_FORM_data4
21755 and DW_FORM_data8 are members of both the constant class, and of
21756 the classes that contain offsets into other debug sections
21757 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21758 that, if an attribute's can be either a constant or one of the
21759 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21760 taken as section offsets, not constants. */
21763 attr_form_is_constant (const struct attribute
*attr
)
21765 switch (attr
->form
)
21767 case DW_FORM_sdata
:
21768 case DW_FORM_udata
:
21769 case DW_FORM_data1
:
21770 case DW_FORM_data2
:
21771 case DW_FORM_data4
:
21772 case DW_FORM_data8
:
21780 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21781 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21784 attr_form_is_ref (const struct attribute
*attr
)
21786 switch (attr
->form
)
21788 case DW_FORM_ref_addr
:
21793 case DW_FORM_ref_udata
:
21794 case DW_FORM_GNU_ref_alt
:
21801 /* Return the .debug_loc section to use for CU.
21802 For DWO files use .debug_loc.dwo. */
21804 static struct dwarf2_section_info
*
21805 cu_debug_loc_section (struct dwarf2_cu
*cu
)
21808 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
21809 return &dwarf2_per_objfile
->loc
;
21812 /* A helper function that fills in a dwarf2_loclist_baton. */
21815 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
21816 struct dwarf2_loclist_baton
*baton
,
21817 const struct attribute
*attr
)
21819 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21821 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
21823 baton
->per_cu
= cu
->per_cu
;
21824 gdb_assert (baton
->per_cu
);
21825 /* We don't know how long the location list is, but make sure we
21826 don't run off the edge of the section. */
21827 baton
->size
= section
->size
- DW_UNSND (attr
);
21828 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
21829 baton
->base_address
= cu
->base_address
;
21830 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
21834 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
21835 struct dwarf2_cu
*cu
, int is_block
)
21837 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21838 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21840 if (attr_form_is_section_offset (attr
)
21841 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21842 the section. If so, fall through to the complaint in the
21844 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
21846 struct dwarf2_loclist_baton
*baton
;
21848 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21849 sizeof (struct dwarf2_loclist_baton
));
21851 fill_in_loclist_baton (cu
, baton
, attr
);
21853 if (cu
->base_known
== 0)
21854 complaint (&symfile_complaints
,
21855 _("Location list used without "
21856 "specifying the CU base address."));
21858 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21859 ? dwarf2_loclist_block_index
21860 : dwarf2_loclist_index
);
21861 SYMBOL_LOCATION_BATON (sym
) = baton
;
21865 struct dwarf2_locexpr_baton
*baton
;
21867 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21868 sizeof (struct dwarf2_locexpr_baton
));
21869 baton
->per_cu
= cu
->per_cu
;
21870 gdb_assert (baton
->per_cu
);
21872 if (attr_form_is_block (attr
))
21874 /* Note that we're just copying the block's data pointer
21875 here, not the actual data. We're still pointing into the
21876 info_buffer for SYM's objfile; right now we never release
21877 that buffer, but when we do clean up properly this may
21879 baton
->size
= DW_BLOCK (attr
)->size
;
21880 baton
->data
= DW_BLOCK (attr
)->data
;
21884 dwarf2_invalid_attrib_class_complaint ("location description",
21885 SYMBOL_NATURAL_NAME (sym
));
21889 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21890 ? dwarf2_locexpr_block_index
21891 : dwarf2_locexpr_index
);
21892 SYMBOL_LOCATION_BATON (sym
) = baton
;
21896 /* Return the OBJFILE associated with the compilation unit CU. If CU
21897 came from a separate debuginfo file, then the master objfile is
21901 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
21903 struct objfile
*objfile
= per_cu
->objfile
;
21905 /* Return the master objfile, so that we can report and look up the
21906 correct file containing this variable. */
21907 if (objfile
->separate_debug_objfile_backlink
)
21908 objfile
= objfile
->separate_debug_objfile_backlink
;
21913 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21914 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21915 CU_HEADERP first. */
21917 static const struct comp_unit_head
*
21918 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
21919 struct dwarf2_per_cu_data
*per_cu
)
21921 const gdb_byte
*info_ptr
;
21924 return &per_cu
->cu
->header
;
21926 info_ptr
= per_cu
->section
->buffer
+ per_cu
->offset
.sect_off
;
21928 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
21929 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
21934 /* Return the address size given in the compilation unit header for CU. */
21937 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21939 struct comp_unit_head cu_header_local
;
21940 const struct comp_unit_head
*cu_headerp
;
21942 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21944 return cu_headerp
->addr_size
;
21947 /* Return the offset size given in the compilation unit header for CU. */
21950 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
21952 struct comp_unit_head cu_header_local
;
21953 const struct comp_unit_head
*cu_headerp
;
21955 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21957 return cu_headerp
->offset_size
;
21960 /* See its dwarf2loc.h declaration. */
21963 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21965 struct comp_unit_head cu_header_local
;
21966 const struct comp_unit_head
*cu_headerp
;
21968 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21970 if (cu_headerp
->version
== 2)
21971 return cu_headerp
->addr_size
;
21973 return cu_headerp
->offset_size
;
21976 /* Return the text offset of the CU. The returned offset comes from
21977 this CU's objfile. If this objfile came from a separate debuginfo
21978 file, then the offset may be different from the corresponding
21979 offset in the parent objfile. */
21982 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
21984 struct objfile
*objfile
= per_cu
->objfile
;
21986 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21989 /* Locate the .debug_info compilation unit from CU's objfile which contains
21990 the DIE at OFFSET. Raises an error on failure. */
21992 static struct dwarf2_per_cu_data
*
21993 dwarf2_find_containing_comp_unit (sect_offset offset
,
21994 unsigned int offset_in_dwz
,
21995 struct objfile
*objfile
)
21997 struct dwarf2_per_cu_data
*this_cu
;
21999 const sect_offset
*cu_off
;
22002 high
= dwarf2_per_objfile
->n_comp_units
- 1;
22005 struct dwarf2_per_cu_data
*mid_cu
;
22006 int mid
= low
+ (high
- low
) / 2;
22008 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
22009 cu_off
= &mid_cu
->offset
;
22010 if (mid_cu
->is_dwz
> offset_in_dwz
22011 || (mid_cu
->is_dwz
== offset_in_dwz
22012 && cu_off
->sect_off
>= offset
.sect_off
))
22017 gdb_assert (low
== high
);
22018 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
22019 cu_off
= &this_cu
->offset
;
22020 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
22022 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
22023 error (_("Dwarf Error: could not find partial DIE containing "
22024 "offset 0x%lx [in module %s]"),
22025 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
22027 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
22028 <= offset
.sect_off
);
22029 return dwarf2_per_objfile
->all_comp_units
[low
-1];
22033 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
22034 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
22035 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
22036 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
22037 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
22042 /* Initialize dwarf2_cu CU, owned by PER_CU. */
22045 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
22047 memset (cu
, 0, sizeof (*cu
));
22049 cu
->per_cu
= per_cu
;
22050 cu
->objfile
= per_cu
->objfile
;
22051 obstack_init (&cu
->comp_unit_obstack
);
22054 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
22057 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
22058 enum language pretend_language
)
22060 struct attribute
*attr
;
22062 /* Set the language we're debugging. */
22063 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
22065 set_cu_language (DW_UNSND (attr
), cu
);
22068 cu
->language
= pretend_language
;
22069 cu
->language_defn
= language_def (cu
->language
);
22072 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
22074 cu
->producer
= DW_STRING (attr
);
22077 /* Release one cached compilation unit, CU. We unlink it from the tree
22078 of compilation units, but we don't remove it from the read_in_chain;
22079 the caller is responsible for that.
22080 NOTE: DATA is a void * because this function is also used as a
22081 cleanup routine. */
22084 free_heap_comp_unit (void *data
)
22086 struct dwarf2_cu
*cu
= data
;
22088 gdb_assert (cu
->per_cu
!= NULL
);
22089 cu
->per_cu
->cu
= NULL
;
22092 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22097 /* This cleanup function is passed the address of a dwarf2_cu on the stack
22098 when we're finished with it. We can't free the pointer itself, but be
22099 sure to unlink it from the cache. Also release any associated storage. */
22102 free_stack_comp_unit (void *data
)
22104 struct dwarf2_cu
*cu
= data
;
22106 gdb_assert (cu
->per_cu
!= NULL
);
22107 cu
->per_cu
->cu
= NULL
;
22110 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22111 cu
->partial_dies
= NULL
;
22114 /* Free all cached compilation units. */
22117 free_cached_comp_units (void *data
)
22119 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22121 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22122 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22123 while (per_cu
!= NULL
)
22125 struct dwarf2_per_cu_data
*next_cu
;
22127 next_cu
= per_cu
->cu
->read_in_chain
;
22129 free_heap_comp_unit (per_cu
->cu
);
22130 *last_chain
= next_cu
;
22136 /* Increase the age counter on each cached compilation unit, and free
22137 any that are too old. */
22140 age_cached_comp_units (void)
22142 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22144 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
22145 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22146 while (per_cu
!= NULL
)
22148 per_cu
->cu
->last_used
++;
22149 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
22150 dwarf2_mark (per_cu
->cu
);
22151 per_cu
= per_cu
->cu
->read_in_chain
;
22154 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22155 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22156 while (per_cu
!= NULL
)
22158 struct dwarf2_per_cu_data
*next_cu
;
22160 next_cu
= per_cu
->cu
->read_in_chain
;
22162 if (!per_cu
->cu
->mark
)
22164 free_heap_comp_unit (per_cu
->cu
);
22165 *last_chain
= next_cu
;
22168 last_chain
= &per_cu
->cu
->read_in_chain
;
22174 /* Remove a single compilation unit from the cache. */
22177 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
22179 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22181 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22182 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22183 while (per_cu
!= NULL
)
22185 struct dwarf2_per_cu_data
*next_cu
;
22187 next_cu
= per_cu
->cu
->read_in_chain
;
22189 if (per_cu
== target_per_cu
)
22191 free_heap_comp_unit (per_cu
->cu
);
22193 *last_chain
= next_cu
;
22197 last_chain
= &per_cu
->cu
->read_in_chain
;
22203 /* Release all extra memory associated with OBJFILE. */
22206 dwarf2_free_objfile (struct objfile
*objfile
)
22208 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
22210 if (dwarf2_per_objfile
== NULL
)
22213 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
22214 free_cached_comp_units (NULL
);
22216 if (dwarf2_per_objfile
->quick_file_names_table
)
22217 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
22219 if (dwarf2_per_objfile
->line_header_hash
)
22220 htab_delete (dwarf2_per_objfile
->line_header_hash
);
22222 /* Everything else should be on the objfile obstack. */
22225 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
22226 We store these in a hash table separate from the DIEs, and preserve them
22227 when the DIEs are flushed out of cache.
22229 The CU "per_cu" pointer is needed because offset alone is not enough to
22230 uniquely identify the type. A file may have multiple .debug_types sections,
22231 or the type may come from a DWO file. Furthermore, while it's more logical
22232 to use per_cu->section+offset, with Fission the section with the data is in
22233 the DWO file but we don't know that section at the point we need it.
22234 We have to use something in dwarf2_per_cu_data (or the pointer to it)
22235 because we can enter the lookup routine, get_die_type_at_offset, from
22236 outside this file, and thus won't necessarily have PER_CU->cu.
22237 Fortunately, PER_CU is stable for the life of the objfile. */
22239 struct dwarf2_per_cu_offset_and_type
22241 const struct dwarf2_per_cu_data
*per_cu
;
22242 sect_offset offset
;
22246 /* Hash function for a dwarf2_per_cu_offset_and_type. */
22249 per_cu_offset_and_type_hash (const void *item
)
22251 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
22253 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
22256 /* Equality function for a dwarf2_per_cu_offset_and_type. */
22259 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
22261 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
22262 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
22264 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
22265 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
22268 /* Set the type associated with DIE to TYPE. Save it in CU's hash
22269 table if necessary. For convenience, return TYPE.
22271 The DIEs reading must have careful ordering to:
22272 * Not cause infite loops trying to read in DIEs as a prerequisite for
22273 reading current DIE.
22274 * Not trying to dereference contents of still incompletely read in types
22275 while reading in other DIEs.
22276 * Enable referencing still incompletely read in types just by a pointer to
22277 the type without accessing its fields.
22279 Therefore caller should follow these rules:
22280 * Try to fetch any prerequisite types we may need to build this DIE type
22281 before building the type and calling set_die_type.
22282 * After building type call set_die_type for current DIE as soon as
22283 possible before fetching more types to complete the current type.
22284 * Make the type as complete as possible before fetching more types. */
22286 static struct type
*
22287 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
22289 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
22290 struct objfile
*objfile
= cu
->objfile
;
22291 struct attribute
*attr
;
22292 struct dynamic_prop prop
;
22294 /* For Ada types, make sure that the gnat-specific data is always
22295 initialized (if not already set). There are a few types where
22296 we should not be doing so, because the type-specific area is
22297 already used to hold some other piece of info (eg: TYPE_CODE_FLT
22298 where the type-specific area is used to store the floatformat).
22299 But this is not a problem, because the gnat-specific information
22300 is actually not needed for these types. */
22301 if (need_gnat_info (cu
)
22302 && TYPE_CODE (type
) != TYPE_CODE_FUNC
22303 && TYPE_CODE (type
) != TYPE_CODE_FLT
22304 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
22305 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
22306 && TYPE_CODE (type
) != TYPE_CODE_METHOD
22307 && !HAVE_GNAT_AUX_INFO (type
))
22308 INIT_GNAT_SPECIFIC (type
);
22310 /* Read DW_AT_data_location and set in type. */
22311 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
22312 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
22313 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
, objfile
);
22315 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22317 dwarf2_per_objfile
->die_type_hash
=
22318 htab_create_alloc_ex (127,
22319 per_cu_offset_and_type_hash
,
22320 per_cu_offset_and_type_eq
,
22322 &objfile
->objfile_obstack
,
22323 hashtab_obstack_allocate
,
22324 dummy_obstack_deallocate
);
22327 ofs
.per_cu
= cu
->per_cu
;
22328 ofs
.offset
= die
->offset
;
22330 slot
= (struct dwarf2_per_cu_offset_and_type
**)
22331 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
22333 complaint (&symfile_complaints
,
22334 _("A problem internal to GDB: DIE 0x%x has type already set"),
22335 die
->offset
.sect_off
);
22336 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
22341 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
22342 or return NULL if the die does not have a saved type. */
22344 static struct type
*
22345 get_die_type_at_offset (sect_offset offset
,
22346 struct dwarf2_per_cu_data
*per_cu
)
22348 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
22350 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22353 ofs
.per_cu
= per_cu
;
22354 ofs
.offset
= offset
;
22355 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
22362 /* Look up the type for DIE in CU in die_type_hash,
22363 or return NULL if DIE does not have a saved type. */
22365 static struct type
*
22366 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22368 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
22371 /* Add a dependence relationship from CU to REF_PER_CU. */
22374 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
22375 struct dwarf2_per_cu_data
*ref_per_cu
)
22379 if (cu
->dependencies
== NULL
)
22381 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
22382 NULL
, &cu
->comp_unit_obstack
,
22383 hashtab_obstack_allocate
,
22384 dummy_obstack_deallocate
);
22386 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
22388 *slot
= ref_per_cu
;
22391 /* Subroutine of dwarf2_mark to pass to htab_traverse.
22392 Set the mark field in every compilation unit in the
22393 cache that we must keep because we are keeping CU. */
22396 dwarf2_mark_helper (void **slot
, void *data
)
22398 struct dwarf2_per_cu_data
*per_cu
;
22400 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
22402 /* cu->dependencies references may not yet have been ever read if QUIT aborts
22403 reading of the chain. As such dependencies remain valid it is not much
22404 useful to track and undo them during QUIT cleanups. */
22405 if (per_cu
->cu
== NULL
)
22408 if (per_cu
->cu
->mark
)
22410 per_cu
->cu
->mark
= 1;
22412 if (per_cu
->cu
->dependencies
!= NULL
)
22413 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22418 /* Set the mark field in CU and in every other compilation unit in the
22419 cache that we must keep because we are keeping CU. */
22422 dwarf2_mark (struct dwarf2_cu
*cu
)
22427 if (cu
->dependencies
!= NULL
)
22428 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22432 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
22436 per_cu
->cu
->mark
= 0;
22437 per_cu
= per_cu
->cu
->read_in_chain
;
22441 /* Trivial hash function for partial_die_info: the hash value of a DIE
22442 is its offset in .debug_info for this objfile. */
22445 partial_die_hash (const void *item
)
22447 const struct partial_die_info
*part_die
= item
;
22449 return part_die
->offset
.sect_off
;
22452 /* Trivial comparison function for partial_die_info structures: two DIEs
22453 are equal if they have the same offset. */
22456 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
22458 const struct partial_die_info
*part_die_lhs
= item_lhs
;
22459 const struct partial_die_info
*part_die_rhs
= item_rhs
;
22461 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
22464 static struct cmd_list_element
*set_dwarf_cmdlist
;
22465 static struct cmd_list_element
*show_dwarf_cmdlist
;
22468 set_dwarf_cmd (char *args
, int from_tty
)
22470 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
22475 show_dwarf_cmd (char *args
, int from_tty
)
22477 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
22480 /* Free data associated with OBJFILE, if necessary. */
22483 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
22485 struct dwarf2_per_objfile
*data
= d
;
22488 /* Make sure we don't accidentally use dwarf2_per_objfile while
22490 dwarf2_per_objfile
= NULL
;
22492 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
22493 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
22495 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
22496 VEC_free (dwarf2_per_cu_ptr
,
22497 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
22498 xfree (data
->all_type_units
);
22500 VEC_free (dwarf2_section_info_def
, data
->types
);
22502 if (data
->dwo_files
)
22503 free_dwo_files (data
->dwo_files
, objfile
);
22504 if (data
->dwp_file
)
22505 gdb_bfd_unref (data
->dwp_file
->dbfd
);
22507 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
22508 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
22512 /* The "save gdb-index" command. */
22514 /* The contents of the hash table we create when building the string
22516 struct strtab_entry
22518 offset_type offset
;
22522 /* Hash function for a strtab_entry.
22524 Function is used only during write_hash_table so no index format backward
22525 compatibility is needed. */
22528 hash_strtab_entry (const void *e
)
22530 const struct strtab_entry
*entry
= e
;
22531 return mapped_index_string_hash (INT_MAX
, entry
->str
);
22534 /* Equality function for a strtab_entry. */
22537 eq_strtab_entry (const void *a
, const void *b
)
22539 const struct strtab_entry
*ea
= a
;
22540 const struct strtab_entry
*eb
= b
;
22541 return !strcmp (ea
->str
, eb
->str
);
22544 /* Create a strtab_entry hash table. */
22547 create_strtab (void)
22549 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
22550 xfree
, xcalloc
, xfree
);
22553 /* Add a string to the constant pool. Return the string's offset in
22557 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
22560 struct strtab_entry entry
;
22561 struct strtab_entry
*result
;
22564 slot
= htab_find_slot (table
, &entry
, INSERT
);
22569 result
= XNEW (struct strtab_entry
);
22570 result
->offset
= obstack_object_size (cpool
);
22572 obstack_grow_str0 (cpool
, str
);
22575 return result
->offset
;
22578 /* An entry in the symbol table. */
22579 struct symtab_index_entry
22581 /* The name of the symbol. */
22583 /* The offset of the name in the constant pool. */
22584 offset_type index_offset
;
22585 /* A sorted vector of the indices of all the CUs that hold an object
22587 VEC (offset_type
) *cu_indices
;
22590 /* The symbol table. This is a power-of-2-sized hash table. */
22591 struct mapped_symtab
22593 offset_type n_elements
;
22595 struct symtab_index_entry
**data
;
22598 /* Hash function for a symtab_index_entry. */
22601 hash_symtab_entry (const void *e
)
22603 const struct symtab_index_entry
*entry
= e
;
22604 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
22605 sizeof (offset_type
) * VEC_length (offset_type
,
22606 entry
->cu_indices
),
22610 /* Equality function for a symtab_index_entry. */
22613 eq_symtab_entry (const void *a
, const void *b
)
22615 const struct symtab_index_entry
*ea
= a
;
22616 const struct symtab_index_entry
*eb
= b
;
22617 int len
= VEC_length (offset_type
, ea
->cu_indices
);
22618 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
22620 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
22621 VEC_address (offset_type
, eb
->cu_indices
),
22622 sizeof (offset_type
) * len
);
22625 /* Destroy a symtab_index_entry. */
22628 delete_symtab_entry (void *p
)
22630 struct symtab_index_entry
*entry
= p
;
22631 VEC_free (offset_type
, entry
->cu_indices
);
22635 /* Create a hash table holding symtab_index_entry objects. */
22638 create_symbol_hash_table (void)
22640 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
22641 delete_symtab_entry
, xcalloc
, xfree
);
22644 /* Create a new mapped symtab object. */
22646 static struct mapped_symtab
*
22647 create_mapped_symtab (void)
22649 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
22650 symtab
->n_elements
= 0;
22651 symtab
->size
= 1024;
22652 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22656 /* Destroy a mapped_symtab. */
22659 cleanup_mapped_symtab (void *p
)
22661 struct mapped_symtab
*symtab
= p
;
22662 /* The contents of the array are freed when the other hash table is
22664 xfree (symtab
->data
);
22668 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22671 Function is used only during write_hash_table so no index format backward
22672 compatibility is needed. */
22674 static struct symtab_index_entry
**
22675 find_slot (struct mapped_symtab
*symtab
, const char *name
)
22677 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
22679 index
= hash
& (symtab
->size
- 1);
22680 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
22684 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
22685 return &symtab
->data
[index
];
22686 index
= (index
+ step
) & (symtab
->size
- 1);
22690 /* Expand SYMTAB's hash table. */
22693 hash_expand (struct mapped_symtab
*symtab
)
22695 offset_type old_size
= symtab
->size
;
22697 struct symtab_index_entry
**old_entries
= symtab
->data
;
22700 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22702 for (i
= 0; i
< old_size
; ++i
)
22704 if (old_entries
[i
])
22706 struct symtab_index_entry
**slot
= find_slot (symtab
,
22707 old_entries
[i
]->name
);
22708 *slot
= old_entries
[i
];
22712 xfree (old_entries
);
22715 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22716 CU_INDEX is the index of the CU in which the symbol appears.
22717 IS_STATIC is one if the symbol is static, otherwise zero (global). */
22720 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
22721 int is_static
, gdb_index_symbol_kind kind
,
22722 offset_type cu_index
)
22724 struct symtab_index_entry
**slot
;
22725 offset_type cu_index_and_attrs
;
22727 ++symtab
->n_elements
;
22728 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
22729 hash_expand (symtab
);
22731 slot
= find_slot (symtab
, name
);
22734 *slot
= XNEW (struct symtab_index_entry
);
22735 (*slot
)->name
= name
;
22736 /* index_offset is set later. */
22737 (*slot
)->cu_indices
= NULL
;
22740 cu_index_and_attrs
= 0;
22741 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
22742 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
22743 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
22745 /* We don't want to record an index value twice as we want to avoid the
22747 We process all global symbols and then all static symbols
22748 (which would allow us to avoid the duplication by only having to check
22749 the last entry pushed), but a symbol could have multiple kinds in one CU.
22750 To keep things simple we don't worry about the duplication here and
22751 sort and uniqufy the list after we've processed all symbols. */
22752 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
22755 /* qsort helper routine for uniquify_cu_indices. */
22758 offset_type_compare (const void *ap
, const void *bp
)
22760 offset_type a
= *(offset_type
*) ap
;
22761 offset_type b
= *(offset_type
*) bp
;
22763 return (a
> b
) - (b
> a
);
22766 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22769 uniquify_cu_indices (struct mapped_symtab
*symtab
)
22773 for (i
= 0; i
< symtab
->size
; ++i
)
22775 struct symtab_index_entry
*entry
= symtab
->data
[i
];
22778 && entry
->cu_indices
!= NULL
)
22780 unsigned int next_to_insert
, next_to_check
;
22781 offset_type last_value
;
22783 qsort (VEC_address (offset_type
, entry
->cu_indices
),
22784 VEC_length (offset_type
, entry
->cu_indices
),
22785 sizeof (offset_type
), offset_type_compare
);
22787 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
22788 next_to_insert
= 1;
22789 for (next_to_check
= 1;
22790 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
22793 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
22796 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
22798 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
22803 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
22808 /* Add a vector of indices to the constant pool. */
22811 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
22812 struct symtab_index_entry
*entry
)
22816 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
22819 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
22820 offset_type val
= MAYBE_SWAP (len
);
22825 entry
->index_offset
= obstack_object_size (cpool
);
22827 obstack_grow (cpool
, &val
, sizeof (val
));
22829 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
22832 val
= MAYBE_SWAP (iter
);
22833 obstack_grow (cpool
, &val
, sizeof (val
));
22838 struct symtab_index_entry
*old_entry
= *slot
;
22839 entry
->index_offset
= old_entry
->index_offset
;
22842 return entry
->index_offset
;
22845 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22846 constant pool entries going into the obstack CPOOL. */
22849 write_hash_table (struct mapped_symtab
*symtab
,
22850 struct obstack
*output
, struct obstack
*cpool
)
22853 htab_t symbol_hash_table
;
22856 symbol_hash_table
= create_symbol_hash_table ();
22857 str_table
= create_strtab ();
22859 /* We add all the index vectors to the constant pool first, to
22860 ensure alignment is ok. */
22861 for (i
= 0; i
< symtab
->size
; ++i
)
22863 if (symtab
->data
[i
])
22864 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
22867 /* Now write out the hash table. */
22868 for (i
= 0; i
< symtab
->size
; ++i
)
22870 offset_type str_off
, vec_off
;
22872 if (symtab
->data
[i
])
22874 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
22875 vec_off
= symtab
->data
[i
]->index_offset
;
22879 /* While 0 is a valid constant pool index, it is not valid
22880 to have 0 for both offsets. */
22885 str_off
= MAYBE_SWAP (str_off
);
22886 vec_off
= MAYBE_SWAP (vec_off
);
22888 obstack_grow (output
, &str_off
, sizeof (str_off
));
22889 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
22892 htab_delete (str_table
);
22893 htab_delete (symbol_hash_table
);
22896 /* Struct to map psymtab to CU index in the index file. */
22897 struct psymtab_cu_index_map
22899 struct partial_symtab
*psymtab
;
22900 unsigned int cu_index
;
22904 hash_psymtab_cu_index (const void *item
)
22906 const struct psymtab_cu_index_map
*map
= item
;
22908 return htab_hash_pointer (map
->psymtab
);
22912 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
22914 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
22915 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
22917 return lhs
->psymtab
== rhs
->psymtab
;
22920 /* Helper struct for building the address table. */
22921 struct addrmap_index_data
22923 struct objfile
*objfile
;
22924 struct obstack
*addr_obstack
;
22925 htab_t cu_index_htab
;
22927 /* Non-zero if the previous_* fields are valid.
22928 We can't write an entry until we see the next entry (since it is only then
22929 that we know the end of the entry). */
22930 int previous_valid
;
22931 /* Index of the CU in the table of all CUs in the index file. */
22932 unsigned int previous_cu_index
;
22933 /* Start address of the CU. */
22934 CORE_ADDR previous_cu_start
;
22937 /* Write an address entry to OBSTACK. */
22940 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
22941 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
22943 offset_type cu_index_to_write
;
22945 CORE_ADDR baseaddr
;
22947 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
22949 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
22950 obstack_grow (obstack
, addr
, 8);
22951 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
22952 obstack_grow (obstack
, addr
, 8);
22953 cu_index_to_write
= MAYBE_SWAP (cu_index
);
22954 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
22957 /* Worker function for traversing an addrmap to build the address table. */
22960 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
22962 struct addrmap_index_data
*data
= datap
;
22963 struct partial_symtab
*pst
= obj
;
22965 if (data
->previous_valid
)
22966 add_address_entry (data
->objfile
, data
->addr_obstack
,
22967 data
->previous_cu_start
, start_addr
,
22968 data
->previous_cu_index
);
22970 data
->previous_cu_start
= start_addr
;
22973 struct psymtab_cu_index_map find_map
, *map
;
22974 find_map
.psymtab
= pst
;
22975 map
= htab_find (data
->cu_index_htab
, &find_map
);
22976 gdb_assert (map
!= NULL
);
22977 data
->previous_cu_index
= map
->cu_index
;
22978 data
->previous_valid
= 1;
22981 data
->previous_valid
= 0;
22986 /* Write OBJFILE's address map to OBSTACK.
22987 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22988 in the index file. */
22991 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
22992 htab_t cu_index_htab
)
22994 struct addrmap_index_data addrmap_index_data
;
22996 /* When writing the address table, we have to cope with the fact that
22997 the addrmap iterator only provides the start of a region; we have to
22998 wait until the next invocation to get the start of the next region. */
23000 addrmap_index_data
.objfile
= objfile
;
23001 addrmap_index_data
.addr_obstack
= obstack
;
23002 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
23003 addrmap_index_data
.previous_valid
= 0;
23005 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
23006 &addrmap_index_data
);
23008 /* It's highly unlikely the last entry (end address = 0xff...ff)
23009 is valid, but we should still handle it.
23010 The end address is recorded as the start of the next region, but that
23011 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
23013 if (addrmap_index_data
.previous_valid
)
23014 add_address_entry (objfile
, obstack
,
23015 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
23016 addrmap_index_data
.previous_cu_index
);
23019 /* Return the symbol kind of PSYM. */
23021 static gdb_index_symbol_kind
23022 symbol_kind (struct partial_symbol
*psym
)
23024 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
23025 enum address_class aclass
= PSYMBOL_CLASS (psym
);
23033 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
23035 return GDB_INDEX_SYMBOL_KIND_TYPE
;
23037 case LOC_CONST_BYTES
:
23038 case LOC_OPTIMIZED_OUT
:
23040 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
23042 /* Note: It's currently impossible to recognize psyms as enum values
23043 short of reading the type info. For now punt. */
23044 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
23046 /* There are other LOC_FOO values that one might want to classify
23047 as variables, but dwarf2read.c doesn't currently use them. */
23048 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23050 case STRUCT_DOMAIN
:
23051 return GDB_INDEX_SYMBOL_KIND_TYPE
;
23053 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23057 /* Add a list of partial symbols to SYMTAB. */
23060 write_psymbols (struct mapped_symtab
*symtab
,
23062 struct partial_symbol
**psymp
,
23064 offset_type cu_index
,
23067 for (; count
-- > 0; ++psymp
)
23069 struct partial_symbol
*psym
= *psymp
;
23072 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
23073 error (_("Ada is not currently supported by the index"));
23075 /* Only add a given psymbol once. */
23076 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
23079 gdb_index_symbol_kind kind
= symbol_kind (psym
);
23082 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
23083 is_static
, kind
, cu_index
);
23088 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
23089 exception if there is an error. */
23092 write_obstack (FILE *file
, struct obstack
*obstack
)
23094 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
23096 != obstack_object_size (obstack
))
23097 error (_("couldn't data write to file"));
23100 /* Unlink a file if the argument is not NULL. */
23103 unlink_if_set (void *p
)
23105 char **filename
= p
;
23107 unlink (*filename
);
23110 /* A helper struct used when iterating over debug_types. */
23111 struct signatured_type_index_data
23113 struct objfile
*objfile
;
23114 struct mapped_symtab
*symtab
;
23115 struct obstack
*types_list
;
23120 /* A helper function that writes a single signatured_type to an
23124 write_one_signatured_type (void **slot
, void *d
)
23126 struct signatured_type_index_data
*info
= d
;
23127 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
23128 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
23131 write_psymbols (info
->symtab
,
23133 info
->objfile
->global_psymbols
.list
23134 + psymtab
->globals_offset
,
23135 psymtab
->n_global_syms
, info
->cu_index
,
23137 write_psymbols (info
->symtab
,
23139 info
->objfile
->static_psymbols
.list
23140 + psymtab
->statics_offset
,
23141 psymtab
->n_static_syms
, info
->cu_index
,
23144 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23145 entry
->per_cu
.offset
.sect_off
);
23146 obstack_grow (info
->types_list
, val
, 8);
23147 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23148 entry
->type_offset_in_tu
.cu_off
);
23149 obstack_grow (info
->types_list
, val
, 8);
23150 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
23151 obstack_grow (info
->types_list
, val
, 8);
23158 /* Recurse into all "included" dependencies and write their symbols as
23159 if they appeared in this psymtab. */
23162 recursively_write_psymbols (struct objfile
*objfile
,
23163 struct partial_symtab
*psymtab
,
23164 struct mapped_symtab
*symtab
,
23166 offset_type cu_index
)
23170 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
23171 if (psymtab
->dependencies
[i
]->user
!= NULL
)
23172 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
23173 symtab
, psyms_seen
, cu_index
);
23175 write_psymbols (symtab
,
23177 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
23178 psymtab
->n_global_syms
, cu_index
,
23180 write_psymbols (symtab
,
23182 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
23183 psymtab
->n_static_syms
, cu_index
,
23187 /* Create an index file for OBJFILE in the directory DIR. */
23190 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
23192 struct cleanup
*cleanup
;
23193 char *filename
, *cleanup_filename
;
23194 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
23195 struct obstack cu_list
, types_cu_list
;
23198 struct mapped_symtab
*symtab
;
23199 offset_type val
, size_of_contents
, total_len
;
23202 htab_t cu_index_htab
;
23203 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
23205 if (dwarf2_per_objfile
->using_index
)
23206 error (_("Cannot use an index to create the index"));
23208 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
23209 error (_("Cannot make an index when the file has multiple .debug_types sections"));
23211 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
23214 if (stat (objfile_name (objfile
), &st
) < 0)
23215 perror_with_name (objfile_name (objfile
));
23217 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile_name (objfile
)),
23218 INDEX_SUFFIX
, (char *) NULL
);
23219 cleanup
= make_cleanup (xfree
, filename
);
23221 out_file
= gdb_fopen_cloexec (filename
, "wb");
23223 error (_("Can't open `%s' for writing"), filename
);
23225 cleanup_filename
= filename
;
23226 make_cleanup (unlink_if_set
, &cleanup_filename
);
23228 symtab
= create_mapped_symtab ();
23229 make_cleanup (cleanup_mapped_symtab
, symtab
);
23231 obstack_init (&addr_obstack
);
23232 make_cleanup_obstack_free (&addr_obstack
);
23234 obstack_init (&cu_list
);
23235 make_cleanup_obstack_free (&cu_list
);
23237 obstack_init (&types_cu_list
);
23238 make_cleanup_obstack_free (&types_cu_list
);
23240 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
23241 NULL
, xcalloc
, xfree
);
23242 make_cleanup_htab_delete (psyms_seen
);
23244 /* While we're scanning CU's create a table that maps a psymtab pointer
23245 (which is what addrmap records) to its index (which is what is recorded
23246 in the index file). This will later be needed to write the address
23248 cu_index_htab
= htab_create_alloc (100,
23249 hash_psymtab_cu_index
,
23250 eq_psymtab_cu_index
,
23251 NULL
, xcalloc
, xfree
);
23252 make_cleanup_htab_delete (cu_index_htab
);
23253 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
23254 xmalloc (sizeof (struct psymtab_cu_index_map
)
23255 * dwarf2_per_objfile
->n_comp_units
);
23256 make_cleanup (xfree
, psymtab_cu_index_map
);
23258 /* The CU list is already sorted, so we don't need to do additional
23259 work here. Also, the debug_types entries do not appear in
23260 all_comp_units, but only in their own hash table. */
23261 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
23263 struct dwarf2_per_cu_data
*per_cu
23264 = dwarf2_per_objfile
->all_comp_units
[i
];
23265 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
23267 struct psymtab_cu_index_map
*map
;
23270 /* CU of a shared file from 'dwz -m' may be unused by this main file.
23271 It may be referenced from a local scope but in such case it does not
23272 need to be present in .gdb_index. */
23273 if (psymtab
== NULL
)
23276 if (psymtab
->user
== NULL
)
23277 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
23279 map
= &psymtab_cu_index_map
[i
];
23280 map
->psymtab
= psymtab
;
23282 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
23283 gdb_assert (slot
!= NULL
);
23284 gdb_assert (*slot
== NULL
);
23287 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23288 per_cu
->offset
.sect_off
);
23289 obstack_grow (&cu_list
, val
, 8);
23290 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
23291 obstack_grow (&cu_list
, val
, 8);
23294 /* Dump the address map. */
23295 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
23297 /* Write out the .debug_type entries, if any. */
23298 if (dwarf2_per_objfile
->signatured_types
)
23300 struct signatured_type_index_data sig_data
;
23302 sig_data
.objfile
= objfile
;
23303 sig_data
.symtab
= symtab
;
23304 sig_data
.types_list
= &types_cu_list
;
23305 sig_data
.psyms_seen
= psyms_seen
;
23306 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
23307 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
23308 write_one_signatured_type
, &sig_data
);
23311 /* Now that we've processed all symbols we can shrink their cu_indices
23313 uniquify_cu_indices (symtab
);
23315 obstack_init (&constant_pool
);
23316 make_cleanup_obstack_free (&constant_pool
);
23317 obstack_init (&symtab_obstack
);
23318 make_cleanup_obstack_free (&symtab_obstack
);
23319 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
23321 obstack_init (&contents
);
23322 make_cleanup_obstack_free (&contents
);
23323 size_of_contents
= 6 * sizeof (offset_type
);
23324 total_len
= size_of_contents
;
23326 /* The version number. */
23327 val
= MAYBE_SWAP (8);
23328 obstack_grow (&contents
, &val
, sizeof (val
));
23330 /* The offset of the CU list from the start of the file. */
23331 val
= MAYBE_SWAP (total_len
);
23332 obstack_grow (&contents
, &val
, sizeof (val
));
23333 total_len
+= obstack_object_size (&cu_list
);
23335 /* The offset of the types CU list from the start of the file. */
23336 val
= MAYBE_SWAP (total_len
);
23337 obstack_grow (&contents
, &val
, sizeof (val
));
23338 total_len
+= obstack_object_size (&types_cu_list
);
23340 /* The offset of the address table from the start of the file. */
23341 val
= MAYBE_SWAP (total_len
);
23342 obstack_grow (&contents
, &val
, sizeof (val
));
23343 total_len
+= obstack_object_size (&addr_obstack
);
23345 /* The offset of the symbol table from the start of the file. */
23346 val
= MAYBE_SWAP (total_len
);
23347 obstack_grow (&contents
, &val
, sizeof (val
));
23348 total_len
+= obstack_object_size (&symtab_obstack
);
23350 /* The offset of the constant pool from the start of the file. */
23351 val
= MAYBE_SWAP (total_len
);
23352 obstack_grow (&contents
, &val
, sizeof (val
));
23353 total_len
+= obstack_object_size (&constant_pool
);
23355 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
23357 write_obstack (out_file
, &contents
);
23358 write_obstack (out_file
, &cu_list
);
23359 write_obstack (out_file
, &types_cu_list
);
23360 write_obstack (out_file
, &addr_obstack
);
23361 write_obstack (out_file
, &symtab_obstack
);
23362 write_obstack (out_file
, &constant_pool
);
23366 /* We want to keep the file, so we set cleanup_filename to NULL
23367 here. See unlink_if_set. */
23368 cleanup_filename
= NULL
;
23370 do_cleanups (cleanup
);
23373 /* Implementation of the `save gdb-index' command.
23375 Note that the file format used by this command is documented in the
23376 GDB manual. Any changes here must be documented there. */
23379 save_gdb_index_command (char *arg
, int from_tty
)
23381 struct objfile
*objfile
;
23384 error (_("usage: save gdb-index DIRECTORY"));
23386 ALL_OBJFILES (objfile
)
23390 /* If the objfile does not correspond to an actual file, skip it. */
23391 if (stat (objfile_name (objfile
), &st
) < 0)
23394 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
23395 if (dwarf2_per_objfile
)
23400 write_psymtabs_to_index (objfile
, arg
);
23402 CATCH (except
, RETURN_MASK_ERROR
)
23404 exception_fprintf (gdb_stderr
, except
,
23405 _("Error while writing index for `%s': "),
23406 objfile_name (objfile
));
23415 int dwarf_always_disassemble
;
23418 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
23419 struct cmd_list_element
*c
, const char *value
)
23421 fprintf_filtered (file
,
23422 _("Whether to always disassemble "
23423 "DWARF expressions is %s.\n"),
23428 show_check_physname (struct ui_file
*file
, int from_tty
,
23429 struct cmd_list_element
*c
, const char *value
)
23431 fprintf_filtered (file
,
23432 _("Whether to check \"physname\" is %s.\n"),
23436 void _initialize_dwarf2_read (void);
23439 _initialize_dwarf2_read (void)
23441 struct cmd_list_element
*c
;
23443 dwarf2_objfile_data_key
23444 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
23446 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
23447 Set DWARF specific variables.\n\
23448 Configure DWARF variables such as the cache size"),
23449 &set_dwarf_cmdlist
, "maintenance set dwarf ",
23450 0/*allow-unknown*/, &maintenance_set_cmdlist
);
23452 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
23453 Show DWARF specific variables\n\
23454 Show DWARF variables such as the cache size"),
23455 &show_dwarf_cmdlist
, "maintenance show dwarf ",
23456 0/*allow-unknown*/, &maintenance_show_cmdlist
);
23458 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
23459 &dwarf_max_cache_age
, _("\
23460 Set the upper bound on the age of cached DWARF compilation units."), _("\
23461 Show the upper bound on the age of cached DWARF compilation units."), _("\
23462 A higher limit means that cached compilation units will be stored\n\
23463 in memory longer, and more total memory will be used. Zero disables\n\
23464 caching, which can slow down startup."),
23466 show_dwarf_max_cache_age
,
23467 &set_dwarf_cmdlist
,
23468 &show_dwarf_cmdlist
);
23470 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
23471 &dwarf_always_disassemble
, _("\
23472 Set whether `info address' always disassembles DWARF expressions."), _("\
23473 Show whether `info address' always disassembles DWARF expressions."), _("\
23474 When enabled, DWARF expressions are always printed in an assembly-like\n\
23475 syntax. When disabled, expressions will be printed in a more\n\
23476 conversational style, when possible."),
23478 show_dwarf_always_disassemble
,
23479 &set_dwarf_cmdlist
,
23480 &show_dwarf_cmdlist
);
23482 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
23483 Set debugging of the DWARF reader."), _("\
23484 Show debugging of the DWARF reader."), _("\
23485 When enabled (non-zero), debugging messages are printed during DWARF\n\
23486 reading and symtab expansion. A value of 1 (one) provides basic\n\
23487 information. A value greater than 1 provides more verbose information."),
23490 &setdebuglist
, &showdebuglist
);
23492 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
23493 Set debugging of the DWARF DIE reader."), _("\
23494 Show debugging of the DWARF DIE reader."), _("\
23495 When enabled (non-zero), DIEs are dumped after they are read in.\n\
23496 The value is the maximum depth to print."),
23499 &setdebuglist
, &showdebuglist
);
23501 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
23502 Set debugging of the dwarf line reader."), _("\
23503 Show debugging of the dwarf line reader."), _("\
23504 When enabled (non-zero), line number entries are dumped as they are read in.\n\
23505 A value of 1 (one) provides basic information.\n\
23506 A value greater than 1 provides more verbose information."),
23509 &setdebuglist
, &showdebuglist
);
23511 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
23512 Set cross-checking of \"physname\" code against demangler."), _("\
23513 Show cross-checking of \"physname\" code against demangler."), _("\
23514 When enabled, GDB's internal \"physname\" code is checked against\n\
23516 NULL
, show_check_physname
,
23517 &setdebuglist
, &showdebuglist
);
23519 add_setshow_boolean_cmd ("use-deprecated-index-sections",
23520 no_class
, &use_deprecated_index_sections
, _("\
23521 Set whether to use deprecated gdb_index sections."), _("\
23522 Show whether to use deprecated gdb_index sections."), _("\
23523 When enabled, deprecated .gdb_index sections are used anyway.\n\
23524 Normally they are ignored either because of a missing feature or\n\
23525 performance issue.\n\
23526 Warning: This option must be enabled before gdb reads the file."),
23529 &setlist
, &showlist
);
23531 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
23533 Save a gdb-index file.\n\
23534 Usage: save gdb-index DIRECTORY"),
23536 set_cmd_completer (c
, filename_completer
);
23538 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23539 &dwarf2_locexpr_funcs
);
23540 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23541 &dwarf2_loclist_funcs
);
23543 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23544 &dwarf2_block_frame_base_locexpr_funcs
);
23545 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23546 &dwarf2_block_frame_base_loclist_funcs
);