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 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
= 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
);
13815 if (attr
) return DW_SND (attr
);
13817 /* GNU F77 is a special case, as at 08/2004 array type info is the
13818 opposite order to the dwarf2 specification, but data is still
13819 laid out as per normal fortran.
13821 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13822 version checking. */
13824 if (cu
->language
== language_fortran
13825 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
13827 return DW_ORD_row_major
;
13830 switch (cu
->language_defn
->la_array_ordering
)
13832 case array_column_major
:
13833 return DW_ORD_col_major
;
13834 case array_row_major
:
13836 return DW_ORD_row_major
;
13840 /* Extract all information from a DW_TAG_set_type DIE and put it in
13841 the DIE's type field. */
13843 static struct type
*
13844 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13846 struct type
*domain_type
, *set_type
;
13847 struct attribute
*attr
;
13849 domain_type
= die_type (die
, cu
);
13851 /* The die_type call above may have already set the type for this DIE. */
13852 set_type
= get_die_type (die
, cu
);
13856 set_type
= create_set_type (NULL
, domain_type
);
13858 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13860 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
13862 return set_die_type (die
, set_type
, cu
);
13865 /* A helper for read_common_block that creates a locexpr baton.
13866 SYM is the symbol which we are marking as computed.
13867 COMMON_DIE is the DIE for the common block.
13868 COMMON_LOC is the location expression attribute for the common
13870 MEMBER_LOC is the location expression attribute for the particular
13871 member of the common block that we are processing.
13872 CU is the CU from which the above come. */
13875 mark_common_block_symbol_computed (struct symbol
*sym
,
13876 struct die_info
*common_die
,
13877 struct attribute
*common_loc
,
13878 struct attribute
*member_loc
,
13879 struct dwarf2_cu
*cu
)
13881 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13882 struct dwarf2_locexpr_baton
*baton
;
13884 unsigned int cu_off
;
13885 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
13886 LONGEST offset
= 0;
13888 gdb_assert (common_loc
&& member_loc
);
13889 gdb_assert (attr_form_is_block (common_loc
));
13890 gdb_assert (attr_form_is_block (member_loc
)
13891 || attr_form_is_constant (member_loc
));
13893 baton
= obstack_alloc (&objfile
->objfile_obstack
,
13894 sizeof (struct dwarf2_locexpr_baton
));
13895 baton
->per_cu
= cu
->per_cu
;
13896 gdb_assert (baton
->per_cu
);
13898 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13900 if (attr_form_is_constant (member_loc
))
13902 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
13903 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
13906 baton
->size
+= DW_BLOCK (member_loc
)->size
;
13908 ptr
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
13911 *ptr
++ = DW_OP_call4
;
13912 cu_off
= common_die
->offset
.sect_off
- cu
->per_cu
->offset
.sect_off
;
13913 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
13916 if (attr_form_is_constant (member_loc
))
13918 *ptr
++ = DW_OP_addr
;
13919 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
13920 ptr
+= cu
->header
.addr_size
;
13924 /* We have to copy the data here, because DW_OP_call4 will only
13925 use a DW_AT_location attribute. */
13926 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
13927 ptr
+= DW_BLOCK (member_loc
)->size
;
13930 *ptr
++ = DW_OP_plus
;
13931 gdb_assert (ptr
- baton
->data
== baton
->size
);
13933 SYMBOL_LOCATION_BATON (sym
) = baton
;
13934 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
13937 /* Create appropriate locally-scoped variables for all the
13938 DW_TAG_common_block entries. Also create a struct common_block
13939 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13940 is used to sepate the common blocks name namespace from regular
13944 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
13946 struct attribute
*attr
;
13948 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13951 /* Support the .debug_loc offsets. */
13952 if (attr_form_is_block (attr
))
13956 else if (attr_form_is_section_offset (attr
))
13958 dwarf2_complex_location_expr_complaint ();
13963 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13964 "common block member");
13969 if (die
->child
!= NULL
)
13971 struct objfile
*objfile
= cu
->objfile
;
13972 struct die_info
*child_die
;
13973 size_t n_entries
= 0, size
;
13974 struct common_block
*common_block
;
13975 struct symbol
*sym
;
13977 for (child_die
= die
->child
;
13978 child_die
&& child_die
->tag
;
13979 child_die
= sibling_die (child_die
))
13982 size
= (sizeof (struct common_block
)
13983 + (n_entries
- 1) * sizeof (struct symbol
*));
13984 common_block
= obstack_alloc (&objfile
->objfile_obstack
, size
);
13985 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
13986 common_block
->n_entries
= 0;
13988 for (child_die
= die
->child
;
13989 child_die
&& child_die
->tag
;
13990 child_die
= sibling_die (child_die
))
13992 /* Create the symbol in the DW_TAG_common_block block in the current
13994 sym
= new_symbol (child_die
, NULL
, cu
);
13997 struct attribute
*member_loc
;
13999 common_block
->contents
[common_block
->n_entries
++] = sym
;
14001 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
14005 /* GDB has handled this for a long time, but it is
14006 not specified by DWARF. It seems to have been
14007 emitted by gfortran at least as recently as:
14008 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
14009 complaint (&symfile_complaints
,
14010 _("Variable in common block has "
14011 "DW_AT_data_member_location "
14012 "- DIE at 0x%x [in module %s]"),
14013 child_die
->offset
.sect_off
,
14014 objfile_name (cu
->objfile
));
14016 if (attr_form_is_section_offset (member_loc
))
14017 dwarf2_complex_location_expr_complaint ();
14018 else if (attr_form_is_constant (member_loc
)
14019 || attr_form_is_block (member_loc
))
14022 mark_common_block_symbol_computed (sym
, die
, attr
,
14026 dwarf2_complex_location_expr_complaint ();
14031 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
14032 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
14036 /* Create a type for a C++ namespace. */
14038 static struct type
*
14039 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14041 struct objfile
*objfile
= cu
->objfile
;
14042 const char *previous_prefix
, *name
;
14046 /* For extensions, reuse the type of the original namespace. */
14047 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
14049 struct die_info
*ext_die
;
14050 struct dwarf2_cu
*ext_cu
= cu
;
14052 ext_die
= dwarf2_extension (die
, &ext_cu
);
14053 type
= read_type_die (ext_die
, ext_cu
);
14055 /* EXT_CU may not be the same as CU.
14056 Ensure TYPE is recorded with CU in die_type_hash. */
14057 return set_die_type (die
, type
, cu
);
14060 name
= namespace_name (die
, &is_anonymous
, cu
);
14062 /* Now build the name of the current namespace. */
14064 previous_prefix
= determine_prefix (die
, cu
);
14065 if (previous_prefix
[0] != '\0')
14066 name
= typename_concat (&objfile
->objfile_obstack
,
14067 previous_prefix
, name
, 0, cu
);
14069 /* Create the type. */
14070 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
14072 TYPE_NAME (type
) = name
;
14073 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14075 return set_die_type (die
, type
, cu
);
14078 /* Read a C++ namespace. */
14081 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
14083 struct objfile
*objfile
= cu
->objfile
;
14086 /* Add a symbol associated to this if we haven't seen the namespace
14087 before. Also, add a using directive if it's an anonymous
14090 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
14094 type
= read_type_die (die
, cu
);
14095 new_symbol (die
, type
, cu
);
14097 namespace_name (die
, &is_anonymous
, cu
);
14100 const char *previous_prefix
= determine_prefix (die
, cu
);
14102 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
14103 NULL
, NULL
, 0, &objfile
->objfile_obstack
);
14107 if (die
->child
!= NULL
)
14109 struct die_info
*child_die
= die
->child
;
14111 while (child_die
&& child_die
->tag
)
14113 process_die (child_die
, cu
);
14114 child_die
= sibling_die (child_die
);
14119 /* Read a Fortran module as type. This DIE can be only a declaration used for
14120 imported module. Still we need that type as local Fortran "use ... only"
14121 declaration imports depend on the created type in determine_prefix. */
14123 static struct type
*
14124 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14126 struct objfile
*objfile
= cu
->objfile
;
14127 const char *module_name
;
14130 module_name
= dwarf2_name (die
, cu
);
14132 complaint (&symfile_complaints
,
14133 _("DW_TAG_module has no name, offset 0x%x"),
14134 die
->offset
.sect_off
);
14135 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
14137 /* determine_prefix uses TYPE_TAG_NAME. */
14138 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
14140 return set_die_type (die
, type
, cu
);
14143 /* Read a Fortran module. */
14146 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
14148 struct die_info
*child_die
= die
->child
;
14151 type
= read_type_die (die
, cu
);
14152 new_symbol (die
, type
, cu
);
14154 while (child_die
&& child_die
->tag
)
14156 process_die (child_die
, cu
);
14157 child_die
= sibling_die (child_die
);
14161 /* Return the name of the namespace represented by DIE. Set
14162 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
14165 static const char *
14166 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
14168 struct die_info
*current_die
;
14169 const char *name
= NULL
;
14171 /* Loop through the extensions until we find a name. */
14173 for (current_die
= die
;
14174 current_die
!= NULL
;
14175 current_die
= dwarf2_extension (die
, &cu
))
14177 /* We don't use dwarf2_name here so that we can detect the absence
14178 of a name -> anonymous namespace. */
14179 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
14182 name
= DW_STRING (attr
);
14187 /* Is it an anonymous namespace? */
14189 *is_anonymous
= (name
== NULL
);
14191 name
= CP_ANONYMOUS_NAMESPACE_STR
;
14196 /* Extract all information from a DW_TAG_pointer_type DIE and add to
14197 the user defined type vector. */
14199 static struct type
*
14200 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14202 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
14203 struct comp_unit_head
*cu_header
= &cu
->header
;
14205 struct attribute
*attr_byte_size
;
14206 struct attribute
*attr_address_class
;
14207 int byte_size
, addr_class
;
14208 struct type
*target_type
;
14210 target_type
= die_type (die
, cu
);
14212 /* The die_type call above may have already set the type for this DIE. */
14213 type
= get_die_type (die
, cu
);
14217 type
= lookup_pointer_type (target_type
);
14219 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14220 if (attr_byte_size
)
14221 byte_size
= DW_UNSND (attr_byte_size
);
14223 byte_size
= cu_header
->addr_size
;
14225 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
14226 if (attr_address_class
)
14227 addr_class
= DW_UNSND (attr_address_class
);
14229 addr_class
= DW_ADDR_none
;
14231 /* If the pointer size or address class is different than the
14232 default, create a type variant marked as such and set the
14233 length accordingly. */
14234 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
14236 if (gdbarch_address_class_type_flags_p (gdbarch
))
14240 type_flags
= gdbarch_address_class_type_flags
14241 (gdbarch
, byte_size
, addr_class
);
14242 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
14244 type
= make_type_with_address_space (type
, type_flags
);
14246 else if (TYPE_LENGTH (type
) != byte_size
)
14248 complaint (&symfile_complaints
,
14249 _("invalid pointer size %d"), byte_size
);
14253 /* Should we also complain about unhandled address classes? */
14257 TYPE_LENGTH (type
) = byte_size
;
14258 return set_die_type (die
, type
, cu
);
14261 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14262 the user defined type vector. */
14264 static struct type
*
14265 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14268 struct type
*to_type
;
14269 struct type
*domain
;
14271 to_type
= die_type (die
, cu
);
14272 domain
= die_containing_type (die
, cu
);
14274 /* The calls above may have already set the type for this DIE. */
14275 type
= get_die_type (die
, cu
);
14279 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
14280 type
= lookup_methodptr_type (to_type
);
14281 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
14283 struct type
*new_type
= alloc_type (cu
->objfile
);
14285 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
14286 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
14287 TYPE_VARARGS (to_type
));
14288 type
= lookup_methodptr_type (new_type
);
14291 type
= lookup_memberptr_type (to_type
, domain
);
14293 return set_die_type (die
, type
, cu
);
14296 /* Extract all information from a DW_TAG_reference_type DIE and add to
14297 the user defined type vector. */
14299 static struct type
*
14300 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14302 struct comp_unit_head
*cu_header
= &cu
->header
;
14303 struct type
*type
, *target_type
;
14304 struct attribute
*attr
;
14306 target_type
= die_type (die
, cu
);
14308 /* The die_type call above may have already set the type for this DIE. */
14309 type
= get_die_type (die
, cu
);
14313 type
= lookup_reference_type (target_type
);
14314 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14317 TYPE_LENGTH (type
) = DW_UNSND (attr
);
14321 TYPE_LENGTH (type
) = cu_header
->addr_size
;
14323 return set_die_type (die
, type
, cu
);
14326 /* Add the given cv-qualifiers to the element type of the array. GCC
14327 outputs DWARF type qualifiers that apply to an array, not the
14328 element type. But GDB relies on the array element type to carry
14329 the cv-qualifiers. This mimics section 6.7.3 of the C99
14332 static struct type
*
14333 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
14334 struct type
*base_type
, int cnst
, int voltl
)
14336 struct type
*el_type
, *inner_array
;
14338 base_type
= copy_type (base_type
);
14339 inner_array
= base_type
;
14341 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
14343 TYPE_TARGET_TYPE (inner_array
) =
14344 copy_type (TYPE_TARGET_TYPE (inner_array
));
14345 inner_array
= TYPE_TARGET_TYPE (inner_array
);
14348 el_type
= TYPE_TARGET_TYPE (inner_array
);
14349 cnst
|= TYPE_CONST (el_type
);
14350 voltl
|= TYPE_VOLATILE (el_type
);
14351 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
14353 return set_die_type (die
, base_type
, cu
);
14356 static struct type
*
14357 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14359 struct type
*base_type
, *cv_type
;
14361 base_type
= die_type (die
, cu
);
14363 /* The die_type call above may have already set the type for this DIE. */
14364 cv_type
= get_die_type (die
, cu
);
14368 /* In case the const qualifier is applied to an array type, the element type
14369 is so qualified, not the array type (section 6.7.3 of C99). */
14370 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14371 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
14373 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
14374 return set_die_type (die
, cv_type
, cu
);
14377 static struct type
*
14378 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14380 struct type
*base_type
, *cv_type
;
14382 base_type
= die_type (die
, cu
);
14384 /* The die_type call above may have already set the type for this DIE. */
14385 cv_type
= get_die_type (die
, cu
);
14389 /* In case the volatile qualifier is applied to an array type, the
14390 element type is so qualified, not the array type (section 6.7.3
14392 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
14393 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
14395 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
14396 return set_die_type (die
, cv_type
, cu
);
14399 /* Handle DW_TAG_restrict_type. */
14401 static struct type
*
14402 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14404 struct type
*base_type
, *cv_type
;
14406 base_type
= die_type (die
, cu
);
14408 /* The die_type call above may have already set the type for this DIE. */
14409 cv_type
= get_die_type (die
, cu
);
14413 cv_type
= make_restrict_type (base_type
);
14414 return set_die_type (die
, cv_type
, cu
);
14417 /* Handle DW_TAG_atomic_type. */
14419 static struct type
*
14420 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14422 struct type
*base_type
, *cv_type
;
14424 base_type
= die_type (die
, cu
);
14426 /* The die_type call above may have already set the type for this DIE. */
14427 cv_type
= get_die_type (die
, cu
);
14431 cv_type
= make_atomic_type (base_type
);
14432 return set_die_type (die
, cv_type
, cu
);
14435 /* Extract all information from a DW_TAG_string_type DIE and add to
14436 the user defined type vector. It isn't really a user defined type,
14437 but it behaves like one, with other DIE's using an AT_user_def_type
14438 attribute to reference it. */
14440 static struct type
*
14441 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14443 struct objfile
*objfile
= cu
->objfile
;
14444 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14445 struct type
*type
, *range_type
, *index_type
, *char_type
;
14446 struct attribute
*attr
;
14447 unsigned int length
;
14449 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
14452 length
= DW_UNSND (attr
);
14456 /* Check for the DW_AT_byte_size attribute. */
14457 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14460 length
= DW_UNSND (attr
);
14468 index_type
= objfile_type (objfile
)->builtin_int
;
14469 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
14470 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
14471 type
= create_string_type (NULL
, char_type
, range_type
);
14473 return set_die_type (die
, type
, cu
);
14476 /* Assuming that DIE corresponds to a function, returns nonzero
14477 if the function is prototyped. */
14480 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
14482 struct attribute
*attr
;
14484 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
14485 if (attr
&& (DW_UNSND (attr
) != 0))
14488 /* The DWARF standard implies that the DW_AT_prototyped attribute
14489 is only meaninful for C, but the concept also extends to other
14490 languages that allow unprototyped functions (Eg: Objective C).
14491 For all other languages, assume that functions are always
14493 if (cu
->language
!= language_c
14494 && cu
->language
!= language_objc
14495 && cu
->language
!= language_opencl
)
14498 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14499 prototyped and unprototyped functions; default to prototyped,
14500 since that is more common in modern code (and RealView warns
14501 about unprototyped functions). */
14502 if (producer_is_realview (cu
->producer
))
14508 /* Handle DIES due to C code like:
14512 int (*funcp)(int a, long l);
14516 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14518 static struct type
*
14519 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14521 struct objfile
*objfile
= cu
->objfile
;
14522 struct type
*type
; /* Type that this function returns. */
14523 struct type
*ftype
; /* Function that returns above type. */
14524 struct attribute
*attr
;
14526 type
= die_type (die
, cu
);
14528 /* The die_type call above may have already set the type for this DIE. */
14529 ftype
= get_die_type (die
, cu
);
14533 ftype
= lookup_function_type (type
);
14535 if (prototyped_function_p (die
, cu
))
14536 TYPE_PROTOTYPED (ftype
) = 1;
14538 /* Store the calling convention in the type if it's available in
14539 the subroutine die. Otherwise set the calling convention to
14540 the default value DW_CC_normal. */
14541 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
14543 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
14544 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
14545 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
14547 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
14549 /* Record whether the function returns normally to its caller or not
14550 if the DWARF producer set that information. */
14551 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
14552 if (attr
&& (DW_UNSND (attr
) != 0))
14553 TYPE_NO_RETURN (ftype
) = 1;
14555 /* We need to add the subroutine type to the die immediately so
14556 we don't infinitely recurse when dealing with parameters
14557 declared as the same subroutine type. */
14558 set_die_type (die
, ftype
, cu
);
14560 if (die
->child
!= NULL
)
14562 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
14563 struct die_info
*child_die
;
14564 int nparams
, iparams
;
14566 /* Count the number of parameters.
14567 FIXME: GDB currently ignores vararg functions, but knows about
14568 vararg member functions. */
14570 child_die
= die
->child
;
14571 while (child_die
&& child_die
->tag
)
14573 if (child_die
->tag
== DW_TAG_formal_parameter
)
14575 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
14576 TYPE_VARARGS (ftype
) = 1;
14577 child_die
= sibling_die (child_die
);
14580 /* Allocate storage for parameters and fill them in. */
14581 TYPE_NFIELDS (ftype
) = nparams
;
14582 TYPE_FIELDS (ftype
) = (struct field
*)
14583 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
14585 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14586 even if we error out during the parameters reading below. */
14587 for (iparams
= 0; iparams
< nparams
; iparams
++)
14588 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
14591 child_die
= die
->child
;
14592 while (child_die
&& child_die
->tag
)
14594 if (child_die
->tag
== DW_TAG_formal_parameter
)
14596 struct type
*arg_type
;
14598 /* DWARF version 2 has no clean way to discern C++
14599 static and non-static member functions. G++ helps
14600 GDB by marking the first parameter for non-static
14601 member functions (which is the this pointer) as
14602 artificial. We pass this information to
14603 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14605 DWARF version 3 added DW_AT_object_pointer, which GCC
14606 4.5 does not yet generate. */
14607 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
14609 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
14612 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
14614 /* GCC/43521: In java, the formal parameter
14615 "this" is sometimes not marked with DW_AT_artificial. */
14616 if (cu
->language
== language_java
)
14618 const char *name
= dwarf2_name (child_die
, cu
);
14620 if (name
&& !strcmp (name
, "this"))
14621 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
14624 arg_type
= die_type (child_die
, cu
);
14626 /* RealView does not mark THIS as const, which the testsuite
14627 expects. GCC marks THIS as const in method definitions,
14628 but not in the class specifications (GCC PR 43053). */
14629 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
14630 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
14633 struct dwarf2_cu
*arg_cu
= cu
;
14634 const char *name
= dwarf2_name (child_die
, cu
);
14636 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
14639 /* If the compiler emits this, use it. */
14640 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
14643 else if (name
&& strcmp (name
, "this") == 0)
14644 /* Function definitions will have the argument names. */
14646 else if (name
== NULL
&& iparams
== 0)
14647 /* Declarations may not have the names, so like
14648 elsewhere in GDB, assume an artificial first
14649 argument is "this". */
14653 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
14657 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
14660 child_die
= sibling_die (child_die
);
14667 static struct type
*
14668 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
14670 struct objfile
*objfile
= cu
->objfile
;
14671 const char *name
= NULL
;
14672 struct type
*this_type
, *target_type
;
14674 name
= dwarf2_full_name (NULL
, die
, cu
);
14675 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
14676 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
14677 TYPE_NAME (this_type
) = name
;
14678 set_die_type (die
, this_type
, cu
);
14679 target_type
= die_type (die
, cu
);
14680 if (target_type
!= this_type
)
14681 TYPE_TARGET_TYPE (this_type
) = target_type
;
14684 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14685 spec and cause infinite loops in GDB. */
14686 complaint (&symfile_complaints
,
14687 _("Self-referential DW_TAG_typedef "
14688 "- DIE at 0x%x [in module %s]"),
14689 die
->offset
.sect_off
, objfile_name (objfile
));
14690 TYPE_TARGET_TYPE (this_type
) = NULL
;
14695 /* Find a representation of a given base type and install
14696 it in the TYPE field of the die. */
14698 static struct type
*
14699 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14701 struct objfile
*objfile
= cu
->objfile
;
14703 struct attribute
*attr
;
14704 int encoding
= 0, size
= 0;
14706 enum type_code code
= TYPE_CODE_INT
;
14707 int type_flags
= 0;
14708 struct type
*target_type
= NULL
;
14710 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
14713 encoding
= DW_UNSND (attr
);
14715 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14718 size
= DW_UNSND (attr
);
14720 name
= dwarf2_name (die
, cu
);
14723 complaint (&symfile_complaints
,
14724 _("DW_AT_name missing from DW_TAG_base_type"));
14729 case DW_ATE_address
:
14730 /* Turn DW_ATE_address into a void * pointer. */
14731 code
= TYPE_CODE_PTR
;
14732 type_flags
|= TYPE_FLAG_UNSIGNED
;
14733 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
14735 case DW_ATE_boolean
:
14736 code
= TYPE_CODE_BOOL
;
14737 type_flags
|= TYPE_FLAG_UNSIGNED
;
14739 case DW_ATE_complex_float
:
14740 code
= TYPE_CODE_COMPLEX
;
14741 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
14743 case DW_ATE_decimal_float
:
14744 code
= TYPE_CODE_DECFLOAT
;
14747 code
= TYPE_CODE_FLT
;
14749 case DW_ATE_signed
:
14751 case DW_ATE_unsigned
:
14752 type_flags
|= TYPE_FLAG_UNSIGNED
;
14753 if (cu
->language
== language_fortran
14755 && startswith (name
, "character("))
14756 code
= TYPE_CODE_CHAR
;
14758 case DW_ATE_signed_char
:
14759 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14760 || cu
->language
== language_pascal
14761 || cu
->language
== language_fortran
)
14762 code
= TYPE_CODE_CHAR
;
14764 case DW_ATE_unsigned_char
:
14765 if (cu
->language
== language_ada
|| cu
->language
== language_m2
14766 || cu
->language
== language_pascal
14767 || cu
->language
== language_fortran
)
14768 code
= TYPE_CODE_CHAR
;
14769 type_flags
|= TYPE_FLAG_UNSIGNED
;
14772 /* We just treat this as an integer and then recognize the
14773 type by name elsewhere. */
14777 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
14778 dwarf_type_encoding_name (encoding
));
14782 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
14783 TYPE_NAME (type
) = name
;
14784 TYPE_TARGET_TYPE (type
) = target_type
;
14786 if (name
&& strcmp (name
, "char") == 0)
14787 TYPE_NOSIGN (type
) = 1;
14789 return set_die_type (die
, type
, cu
);
14792 /* Parse dwarf attribute if it's a block, reference or constant and put the
14793 resulting value of the attribute into struct bound_prop.
14794 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14797 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
14798 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
14800 struct dwarf2_property_baton
*baton
;
14801 struct obstack
*obstack
= &cu
->objfile
->objfile_obstack
;
14803 if (attr
== NULL
|| prop
== NULL
)
14806 if (attr_form_is_block (attr
))
14808 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14809 baton
->referenced_type
= NULL
;
14810 baton
->locexpr
.per_cu
= cu
->per_cu
;
14811 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
14812 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
14813 prop
->data
.baton
= baton
;
14814 prop
->kind
= PROP_LOCEXPR
;
14815 gdb_assert (prop
->data
.baton
!= NULL
);
14817 else if (attr_form_is_ref (attr
))
14819 struct dwarf2_cu
*target_cu
= cu
;
14820 struct die_info
*target_die
;
14821 struct attribute
*target_attr
;
14823 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14824 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
14825 if (target_attr
== NULL
)
14826 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
14828 if (target_attr
== NULL
)
14831 switch (target_attr
->name
)
14833 case DW_AT_location
:
14834 if (attr_form_is_section_offset (target_attr
))
14836 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14837 baton
->referenced_type
= die_type (target_die
, target_cu
);
14838 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
14839 prop
->data
.baton
= baton
;
14840 prop
->kind
= PROP_LOCLIST
;
14841 gdb_assert (prop
->data
.baton
!= NULL
);
14843 else if (attr_form_is_block (target_attr
))
14845 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14846 baton
->referenced_type
= die_type (target_die
, target_cu
);
14847 baton
->locexpr
.per_cu
= cu
->per_cu
;
14848 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
14849 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
14850 prop
->data
.baton
= baton
;
14851 prop
->kind
= PROP_LOCEXPR
;
14852 gdb_assert (prop
->data
.baton
!= NULL
);
14856 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14857 "dynamic property");
14861 case DW_AT_data_member_location
:
14865 if (!handle_data_member_location (target_die
, target_cu
,
14869 baton
= obstack_alloc (obstack
, sizeof (*baton
));
14870 baton
->referenced_type
= read_type_die (target_die
->parent
,
14872 baton
->offset_info
.offset
= offset
;
14873 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
14874 prop
->data
.baton
= baton
;
14875 prop
->kind
= PROP_ADDR_OFFSET
;
14880 else if (attr_form_is_constant (attr
))
14882 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
14883 prop
->kind
= PROP_CONST
;
14887 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
14888 dwarf2_name (die
, cu
));
14895 /* Read the given DW_AT_subrange DIE. */
14897 static struct type
*
14898 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14900 struct type
*base_type
, *orig_base_type
;
14901 struct type
*range_type
;
14902 struct attribute
*attr
;
14903 struct dynamic_prop low
, high
;
14904 int low_default_is_valid
;
14905 int high_bound_is_count
= 0;
14907 LONGEST negative_mask
;
14909 orig_base_type
= die_type (die
, cu
);
14910 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14911 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14912 creating the range type, but we use the result of check_typedef
14913 when examining properties of the type. */
14914 base_type
= check_typedef (orig_base_type
);
14916 /* The die_type call above may have already set the type for this DIE. */
14917 range_type
= get_die_type (die
, cu
);
14921 low
.kind
= PROP_CONST
;
14922 high
.kind
= PROP_CONST
;
14923 high
.data
.const_val
= 0;
14925 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14926 omitting DW_AT_lower_bound. */
14927 switch (cu
->language
)
14930 case language_cplus
:
14931 low
.data
.const_val
= 0;
14932 low_default_is_valid
= 1;
14934 case language_fortran
:
14935 low
.data
.const_val
= 1;
14936 low_default_is_valid
= 1;
14939 case language_java
:
14940 case language_objc
:
14941 low
.data
.const_val
= 0;
14942 low_default_is_valid
= (cu
->header
.version
>= 4);
14946 case language_pascal
:
14947 low
.data
.const_val
= 1;
14948 low_default_is_valid
= (cu
->header
.version
>= 4);
14951 low
.data
.const_val
= 0;
14952 low_default_is_valid
= 0;
14956 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
14958 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
14959 else if (!low_default_is_valid
)
14960 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
14961 "- DIE at 0x%x [in module %s]"),
14962 die
->offset
.sect_off
, objfile_name (cu
->objfile
));
14964 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
14965 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14967 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
14968 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
14970 /* If bounds are constant do the final calculation here. */
14971 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
14972 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
14974 high_bound_is_count
= 1;
14978 /* Dwarf-2 specifications explicitly allows to create subrange types
14979 without specifying a base type.
14980 In that case, the base type must be set to the type of
14981 the lower bound, upper bound or count, in that order, if any of these
14982 three attributes references an object that has a type.
14983 If no base type is found, the Dwarf-2 specifications say that
14984 a signed integer type of size equal to the size of an address should
14986 For the following C code: `extern char gdb_int [];'
14987 GCC produces an empty range DIE.
14988 FIXME: muller/2010-05-28: Possible references to object for low bound,
14989 high bound or count are not yet handled by this code. */
14990 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
14992 struct objfile
*objfile
= cu
->objfile
;
14993 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14994 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
14995 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
14997 /* Test "int", "long int", and "long long int" objfile types,
14998 and select the first one having a size above or equal to the
14999 architecture address size. */
15000 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15001 base_type
= int_type
;
15004 int_type
= objfile_type (objfile
)->builtin_long
;
15005 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15006 base_type
= int_type
;
15009 int_type
= objfile_type (objfile
)->builtin_long_long
;
15010 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
15011 base_type
= int_type
;
15016 /* Normally, the DWARF producers are expected to use a signed
15017 constant form (Eg. DW_FORM_sdata) to express negative bounds.
15018 But this is unfortunately not always the case, as witnessed
15019 with GCC, for instance, where the ambiguous DW_FORM_dataN form
15020 is used instead. To work around that ambiguity, we treat
15021 the bounds as signed, and thus sign-extend their values, when
15022 the base type is signed. */
15024 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
15025 if (low
.kind
== PROP_CONST
15026 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
15027 low
.data
.const_val
|= negative_mask
;
15028 if (high
.kind
== PROP_CONST
15029 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
15030 high
.data
.const_val
|= negative_mask
;
15032 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
15034 if (high_bound_is_count
)
15035 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
15037 /* Ada expects an empty array on no boundary attributes. */
15038 if (attr
== NULL
&& cu
->language
!= language_ada
)
15039 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
15041 name
= dwarf2_name (die
, cu
);
15043 TYPE_NAME (range_type
) = name
;
15045 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15047 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
15049 set_die_type (die
, range_type
, cu
);
15051 /* set_die_type should be already done. */
15052 set_descriptive_type (range_type
, die
, cu
);
15057 static struct type
*
15058 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15062 /* For now, we only support the C meaning of an unspecified type: void. */
15064 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
15065 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
15067 return set_die_type (die
, type
, cu
);
15070 /* Read a single die and all its descendents. Set the die's sibling
15071 field to NULL; set other fields in the die correctly, and set all
15072 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
15073 location of the info_ptr after reading all of those dies. PARENT
15074 is the parent of the die in question. */
15076 static struct die_info
*
15077 read_die_and_children (const struct die_reader_specs
*reader
,
15078 const gdb_byte
*info_ptr
,
15079 const gdb_byte
**new_info_ptr
,
15080 struct die_info
*parent
)
15082 struct die_info
*die
;
15083 const gdb_byte
*cur_ptr
;
15086 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
15089 *new_info_ptr
= cur_ptr
;
15092 store_in_ref_table (die
, reader
->cu
);
15095 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
15099 *new_info_ptr
= cur_ptr
;
15102 die
->sibling
= NULL
;
15103 die
->parent
= parent
;
15107 /* Read a die, all of its descendents, and all of its siblings; set
15108 all of the fields of all of the dies correctly. Arguments are as
15109 in read_die_and_children. */
15111 static struct die_info
*
15112 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
15113 const gdb_byte
*info_ptr
,
15114 const gdb_byte
**new_info_ptr
,
15115 struct die_info
*parent
)
15117 struct die_info
*first_die
, *last_sibling
;
15118 const gdb_byte
*cur_ptr
;
15120 cur_ptr
= info_ptr
;
15121 first_die
= last_sibling
= NULL
;
15125 struct die_info
*die
15126 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
15130 *new_info_ptr
= cur_ptr
;
15137 last_sibling
->sibling
= die
;
15139 last_sibling
= die
;
15143 /* Read a die, all of its descendents, and all of its siblings; set
15144 all of the fields of all of the dies correctly. Arguments are as
15145 in read_die_and_children.
15146 This the main entry point for reading a DIE and all its children. */
15148 static struct die_info
*
15149 read_die_and_siblings (const struct die_reader_specs
*reader
,
15150 const gdb_byte
*info_ptr
,
15151 const gdb_byte
**new_info_ptr
,
15152 struct die_info
*parent
)
15154 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
15155 new_info_ptr
, parent
);
15157 if (dwarf_die_debug
)
15159 fprintf_unfiltered (gdb_stdlog
,
15160 "Read die from %s@0x%x of %s:\n",
15161 get_section_name (reader
->die_section
),
15162 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15163 bfd_get_filename (reader
->abfd
));
15164 dump_die (die
, dwarf_die_debug
);
15170 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
15172 The caller is responsible for filling in the extra attributes
15173 and updating (*DIEP)->num_attrs.
15174 Set DIEP to point to a newly allocated die with its information,
15175 except for its child, sibling, and parent fields.
15176 Set HAS_CHILDREN to tell whether the die has children or not. */
15178 static const gdb_byte
*
15179 read_full_die_1 (const struct die_reader_specs
*reader
,
15180 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15181 int *has_children
, int num_extra_attrs
)
15183 unsigned int abbrev_number
, bytes_read
, i
;
15184 sect_offset offset
;
15185 struct abbrev_info
*abbrev
;
15186 struct die_info
*die
;
15187 struct dwarf2_cu
*cu
= reader
->cu
;
15188 bfd
*abfd
= reader
->abfd
;
15190 offset
.sect_off
= info_ptr
- reader
->buffer
;
15191 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
15192 info_ptr
+= bytes_read
;
15193 if (!abbrev_number
)
15200 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
15202 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
15204 bfd_get_filename (abfd
));
15206 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
15207 die
->offset
= offset
;
15208 die
->tag
= abbrev
->tag
;
15209 die
->abbrev
= abbrev_number
;
15211 /* Make the result usable.
15212 The caller needs to update num_attrs after adding the extra
15214 die
->num_attrs
= abbrev
->num_attrs
;
15216 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15217 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
15221 *has_children
= abbrev
->has_children
;
15225 /* Read a die and all its attributes.
15226 Set DIEP to point to a newly allocated die with its information,
15227 except for its child, sibling, and parent fields.
15228 Set HAS_CHILDREN to tell whether the die has children or not. */
15230 static const gdb_byte
*
15231 read_full_die (const struct die_reader_specs
*reader
,
15232 struct die_info
**diep
, const gdb_byte
*info_ptr
,
15235 const gdb_byte
*result
;
15237 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
15239 if (dwarf_die_debug
)
15241 fprintf_unfiltered (gdb_stdlog
,
15242 "Read die from %s@0x%x of %s:\n",
15243 get_section_name (reader
->die_section
),
15244 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
15245 bfd_get_filename (reader
->abfd
));
15246 dump_die (*diep
, dwarf_die_debug
);
15252 /* Abbreviation tables.
15254 In DWARF version 2, the description of the debugging information is
15255 stored in a separate .debug_abbrev section. Before we read any
15256 dies from a section we read in all abbreviations and install them
15257 in a hash table. */
15259 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
15261 static struct abbrev_info
*
15262 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
15264 struct abbrev_info
*abbrev
;
15266 abbrev
= (struct abbrev_info
*)
15267 obstack_alloc (&abbrev_table
->abbrev_obstack
, sizeof (struct abbrev_info
));
15268 memset (abbrev
, 0, sizeof (struct abbrev_info
));
15272 /* Add an abbreviation to the table. */
15275 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
15276 unsigned int abbrev_number
,
15277 struct abbrev_info
*abbrev
)
15279 unsigned int hash_number
;
15281 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15282 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
15283 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
15286 /* Look up an abbrev in the table.
15287 Returns NULL if the abbrev is not found. */
15289 static struct abbrev_info
*
15290 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
15291 unsigned int abbrev_number
)
15293 unsigned int hash_number
;
15294 struct abbrev_info
*abbrev
;
15296 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
15297 abbrev
= abbrev_table
->abbrevs
[hash_number
];
15301 if (abbrev
->number
== abbrev_number
)
15303 abbrev
= abbrev
->next
;
15308 /* Read in an abbrev table. */
15310 static struct abbrev_table
*
15311 abbrev_table_read_table (struct dwarf2_section_info
*section
,
15312 sect_offset offset
)
15314 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15315 bfd
*abfd
= get_section_bfd_owner (section
);
15316 struct abbrev_table
*abbrev_table
;
15317 const gdb_byte
*abbrev_ptr
;
15318 struct abbrev_info
*cur_abbrev
;
15319 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
15320 unsigned int abbrev_form
;
15321 struct attr_abbrev
*cur_attrs
;
15322 unsigned int allocated_attrs
;
15324 abbrev_table
= XNEW (struct abbrev_table
);
15325 abbrev_table
->offset
= offset
;
15326 obstack_init (&abbrev_table
->abbrev_obstack
);
15327 abbrev_table
->abbrevs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15329 * sizeof (struct abbrev_info
*)));
15330 memset (abbrev_table
->abbrevs
, 0,
15331 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
15333 dwarf2_read_section (objfile
, section
);
15334 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
15335 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15336 abbrev_ptr
+= bytes_read
;
15338 allocated_attrs
= ATTR_ALLOC_CHUNK
;
15339 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
15341 /* Loop until we reach an abbrev number of 0. */
15342 while (abbrev_number
)
15344 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
15346 /* read in abbrev header */
15347 cur_abbrev
->number
= abbrev_number
;
15348 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15349 abbrev_ptr
+= bytes_read
;
15350 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
15353 /* now read in declarations */
15354 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15355 abbrev_ptr
+= bytes_read
;
15356 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15357 abbrev_ptr
+= bytes_read
;
15358 while (abbrev_name
)
15360 if (cur_abbrev
->num_attrs
== allocated_attrs
)
15362 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
15364 = xrealloc (cur_attrs
, (allocated_attrs
15365 * sizeof (struct attr_abbrev
)));
15368 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
15369 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
15370 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15371 abbrev_ptr
+= bytes_read
;
15372 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15373 abbrev_ptr
+= bytes_read
;
15376 cur_abbrev
->attrs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
15377 (cur_abbrev
->num_attrs
15378 * sizeof (struct attr_abbrev
)));
15379 memcpy (cur_abbrev
->attrs
, cur_attrs
,
15380 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
15382 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
15384 /* Get next abbreviation.
15385 Under Irix6 the abbreviations for a compilation unit are not
15386 always properly terminated with an abbrev number of 0.
15387 Exit loop if we encounter an abbreviation which we have
15388 already read (which means we are about to read the abbreviations
15389 for the next compile unit) or if the end of the abbreviation
15390 table is reached. */
15391 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
15393 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
15394 abbrev_ptr
+= bytes_read
;
15395 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
15400 return abbrev_table
;
15403 /* Free the resources held by ABBREV_TABLE. */
15406 abbrev_table_free (struct abbrev_table
*abbrev_table
)
15408 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
15409 xfree (abbrev_table
);
15412 /* Same as abbrev_table_free but as a cleanup.
15413 We pass in a pointer to the pointer to the table so that we can
15414 set the pointer to NULL when we're done. It also simplifies
15415 build_type_psymtabs_1. */
15418 abbrev_table_free_cleanup (void *table_ptr
)
15420 struct abbrev_table
**abbrev_table_ptr
= table_ptr
;
15422 if (*abbrev_table_ptr
!= NULL
)
15423 abbrev_table_free (*abbrev_table_ptr
);
15424 *abbrev_table_ptr
= NULL
;
15427 /* Read the abbrev table for CU from ABBREV_SECTION. */
15430 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
15431 struct dwarf2_section_info
*abbrev_section
)
15434 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
15437 /* Release the memory used by the abbrev table for a compilation unit. */
15440 dwarf2_free_abbrev_table (void *ptr_to_cu
)
15442 struct dwarf2_cu
*cu
= ptr_to_cu
;
15444 if (cu
->abbrev_table
!= NULL
)
15445 abbrev_table_free (cu
->abbrev_table
);
15446 /* Set this to NULL so that we SEGV if we try to read it later,
15447 and also because free_comp_unit verifies this is NULL. */
15448 cu
->abbrev_table
= NULL
;
15451 /* Returns nonzero if TAG represents a type that we might generate a partial
15455 is_type_tag_for_partial (int tag
)
15460 /* Some types that would be reasonable to generate partial symbols for,
15461 that we don't at present. */
15462 case DW_TAG_array_type
:
15463 case DW_TAG_file_type
:
15464 case DW_TAG_ptr_to_member_type
:
15465 case DW_TAG_set_type
:
15466 case DW_TAG_string_type
:
15467 case DW_TAG_subroutine_type
:
15469 case DW_TAG_base_type
:
15470 case DW_TAG_class_type
:
15471 case DW_TAG_interface_type
:
15472 case DW_TAG_enumeration_type
:
15473 case DW_TAG_structure_type
:
15474 case DW_TAG_subrange_type
:
15475 case DW_TAG_typedef
:
15476 case DW_TAG_union_type
:
15483 /* Load all DIEs that are interesting for partial symbols into memory. */
15485 static struct partial_die_info
*
15486 load_partial_dies (const struct die_reader_specs
*reader
,
15487 const gdb_byte
*info_ptr
, int building_psymtab
)
15489 struct dwarf2_cu
*cu
= reader
->cu
;
15490 struct objfile
*objfile
= cu
->objfile
;
15491 struct partial_die_info
*part_die
;
15492 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
15493 struct abbrev_info
*abbrev
;
15494 unsigned int bytes_read
;
15495 unsigned int load_all
= 0;
15496 int nesting_level
= 1;
15501 gdb_assert (cu
->per_cu
!= NULL
);
15502 if (cu
->per_cu
->load_all_dies
)
15506 = htab_create_alloc_ex (cu
->header
.length
/ 12,
15510 &cu
->comp_unit_obstack
,
15511 hashtab_obstack_allocate
,
15512 dummy_obstack_deallocate
);
15514 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15515 sizeof (struct partial_die_info
));
15519 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
15521 /* A NULL abbrev means the end of a series of children. */
15522 if (abbrev
== NULL
)
15524 if (--nesting_level
== 0)
15526 /* PART_DIE was probably the last thing allocated on the
15527 comp_unit_obstack, so we could call obstack_free
15528 here. We don't do that because the waste is small,
15529 and will be cleaned up when we're done with this
15530 compilation unit. This way, we're also more robust
15531 against other users of the comp_unit_obstack. */
15534 info_ptr
+= bytes_read
;
15535 last_die
= parent_die
;
15536 parent_die
= parent_die
->die_parent
;
15540 /* Check for template arguments. We never save these; if
15541 they're seen, we just mark the parent, and go on our way. */
15542 if (parent_die
!= NULL
15543 && cu
->language
== language_cplus
15544 && (abbrev
->tag
== DW_TAG_template_type_param
15545 || abbrev
->tag
== DW_TAG_template_value_param
))
15547 parent_die
->has_template_arguments
= 1;
15551 /* We don't need a partial DIE for the template argument. */
15552 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15557 /* We only recurse into c++ subprograms looking for template arguments.
15558 Skip their other children. */
15560 && cu
->language
== language_cplus
15561 && parent_die
!= NULL
15562 && parent_die
->tag
== DW_TAG_subprogram
)
15564 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15568 /* Check whether this DIE is interesting enough to save. Normally
15569 we would not be interested in members here, but there may be
15570 later variables referencing them via DW_AT_specification (for
15571 static members). */
15573 && !is_type_tag_for_partial (abbrev
->tag
)
15574 && abbrev
->tag
!= DW_TAG_constant
15575 && abbrev
->tag
!= DW_TAG_enumerator
15576 && abbrev
->tag
!= DW_TAG_subprogram
15577 && abbrev
->tag
!= DW_TAG_lexical_block
15578 && abbrev
->tag
!= DW_TAG_variable
15579 && abbrev
->tag
!= DW_TAG_namespace
15580 && abbrev
->tag
!= DW_TAG_module
15581 && abbrev
->tag
!= DW_TAG_member
15582 && abbrev
->tag
!= DW_TAG_imported_unit
15583 && abbrev
->tag
!= DW_TAG_imported_declaration
)
15585 /* Otherwise we skip to the next sibling, if any. */
15586 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
15590 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
15593 /* This two-pass algorithm for processing partial symbols has a
15594 high cost in cache pressure. Thus, handle some simple cases
15595 here which cover the majority of C partial symbols. DIEs
15596 which neither have specification tags in them, nor could have
15597 specification tags elsewhere pointing at them, can simply be
15598 processed and discarded.
15600 This segment is also optional; scan_partial_symbols and
15601 add_partial_symbol will handle these DIEs if we chain
15602 them in normally. When compilers which do not emit large
15603 quantities of duplicate debug information are more common,
15604 this code can probably be removed. */
15606 /* Any complete simple types at the top level (pretty much all
15607 of them, for a language without namespaces), can be processed
15609 if (parent_die
== NULL
15610 && part_die
->has_specification
== 0
15611 && part_die
->is_declaration
== 0
15612 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
15613 || part_die
->tag
== DW_TAG_base_type
15614 || part_die
->tag
== DW_TAG_subrange_type
))
15616 if (building_psymtab
&& part_die
->name
!= NULL
)
15617 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15618 VAR_DOMAIN
, LOC_TYPEDEF
,
15619 &objfile
->static_psymbols
,
15620 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15621 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15625 /* The exception for DW_TAG_typedef with has_children above is
15626 a workaround of GCC PR debug/47510. In the case of this complaint
15627 type_name_no_tag_or_error will error on such types later.
15629 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15630 it could not find the child DIEs referenced later, this is checked
15631 above. In correct DWARF DW_TAG_typedef should have no children. */
15633 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
15634 complaint (&symfile_complaints
,
15635 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15636 "- DIE at 0x%x [in module %s]"),
15637 part_die
->offset
.sect_off
, objfile_name (objfile
));
15639 /* If we're at the second level, and we're an enumerator, and
15640 our parent has no specification (meaning possibly lives in a
15641 namespace elsewhere), then we can add the partial symbol now
15642 instead of queueing it. */
15643 if (part_die
->tag
== DW_TAG_enumerator
15644 && parent_die
!= NULL
15645 && parent_die
->die_parent
== NULL
15646 && parent_die
->tag
== DW_TAG_enumeration_type
15647 && parent_die
->has_specification
== 0)
15649 if (part_die
->name
== NULL
)
15650 complaint (&symfile_complaints
,
15651 _("malformed enumerator DIE ignored"));
15652 else if (building_psymtab
)
15653 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
15654 VAR_DOMAIN
, LOC_CONST
,
15655 (cu
->language
== language_cplus
15656 || cu
->language
== language_java
)
15657 ? &objfile
->global_psymbols
15658 : &objfile
->static_psymbols
,
15659 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
15661 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
15665 /* We'll save this DIE so link it in. */
15666 part_die
->die_parent
= parent_die
;
15667 part_die
->die_sibling
= NULL
;
15668 part_die
->die_child
= NULL
;
15670 if (last_die
&& last_die
== parent_die
)
15671 last_die
->die_child
= part_die
;
15673 last_die
->die_sibling
= part_die
;
15675 last_die
= part_die
;
15677 if (first_die
== NULL
)
15678 first_die
= part_die
;
15680 /* Maybe add the DIE to the hash table. Not all DIEs that we
15681 find interesting need to be in the hash table, because we
15682 also have the parent/sibling/child chains; only those that we
15683 might refer to by offset later during partial symbol reading.
15685 For now this means things that might have be the target of a
15686 DW_AT_specification, DW_AT_abstract_origin, or
15687 DW_AT_extension. DW_AT_extension will refer only to
15688 namespaces; DW_AT_abstract_origin refers to functions (and
15689 many things under the function DIE, but we do not recurse
15690 into function DIEs during partial symbol reading) and
15691 possibly variables as well; DW_AT_specification refers to
15692 declarations. Declarations ought to have the DW_AT_declaration
15693 flag. It happens that GCC forgets to put it in sometimes, but
15694 only for functions, not for types.
15696 Adding more things than necessary to the hash table is harmless
15697 except for the performance cost. Adding too few will result in
15698 wasted time in find_partial_die, when we reread the compilation
15699 unit with load_all_dies set. */
15702 || abbrev
->tag
== DW_TAG_constant
15703 || abbrev
->tag
== DW_TAG_subprogram
15704 || abbrev
->tag
== DW_TAG_variable
15705 || abbrev
->tag
== DW_TAG_namespace
15706 || part_die
->is_declaration
)
15710 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
15711 part_die
->offset
.sect_off
, INSERT
);
15715 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
15716 sizeof (struct partial_die_info
));
15718 /* For some DIEs we want to follow their children (if any). For C
15719 we have no reason to follow the children of structures; for other
15720 languages we have to, so that we can get at method physnames
15721 to infer fully qualified class names, for DW_AT_specification,
15722 and for C++ template arguments. For C++, we also look one level
15723 inside functions to find template arguments (if the name of the
15724 function does not already contain the template arguments).
15726 For Ada, we need to scan the children of subprograms and lexical
15727 blocks as well because Ada allows the definition of nested
15728 entities that could be interesting for the debugger, such as
15729 nested subprograms for instance. */
15730 if (last_die
->has_children
15732 || last_die
->tag
== DW_TAG_namespace
15733 || last_die
->tag
== DW_TAG_module
15734 || last_die
->tag
== DW_TAG_enumeration_type
15735 || (cu
->language
== language_cplus
15736 && last_die
->tag
== DW_TAG_subprogram
15737 && (last_die
->name
== NULL
15738 || strchr (last_die
->name
, '<') == NULL
))
15739 || (cu
->language
!= language_c
15740 && (last_die
->tag
== DW_TAG_class_type
15741 || last_die
->tag
== DW_TAG_interface_type
15742 || last_die
->tag
== DW_TAG_structure_type
15743 || last_die
->tag
== DW_TAG_union_type
))
15744 || (cu
->language
== language_ada
15745 && (last_die
->tag
== DW_TAG_subprogram
15746 || last_die
->tag
== DW_TAG_lexical_block
))))
15749 parent_die
= last_die
;
15753 /* Otherwise we skip to the next sibling, if any. */
15754 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
15756 /* Back to the top, do it again. */
15760 /* Read a minimal amount of information into the minimal die structure. */
15762 static const gdb_byte
*
15763 read_partial_die (const struct die_reader_specs
*reader
,
15764 struct partial_die_info
*part_die
,
15765 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
15766 const gdb_byte
*info_ptr
)
15768 struct dwarf2_cu
*cu
= reader
->cu
;
15769 struct objfile
*objfile
= cu
->objfile
;
15770 const gdb_byte
*buffer
= reader
->buffer
;
15772 struct attribute attr
;
15773 int has_low_pc_attr
= 0;
15774 int has_high_pc_attr
= 0;
15775 int high_pc_relative
= 0;
15777 memset (part_die
, 0, sizeof (struct partial_die_info
));
15779 part_die
->offset
.sect_off
= info_ptr
- buffer
;
15781 info_ptr
+= abbrev_len
;
15783 if (abbrev
== NULL
)
15786 part_die
->tag
= abbrev
->tag
;
15787 part_die
->has_children
= abbrev
->has_children
;
15789 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
15791 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
15793 /* Store the data if it is of an attribute we want to keep in a
15794 partial symbol table. */
15798 switch (part_die
->tag
)
15800 case DW_TAG_compile_unit
:
15801 case DW_TAG_partial_unit
:
15802 case DW_TAG_type_unit
:
15803 /* Compilation units have a DW_AT_name that is a filename, not
15804 a source language identifier. */
15805 case DW_TAG_enumeration_type
:
15806 case DW_TAG_enumerator
:
15807 /* These tags always have simple identifiers already; no need
15808 to canonicalize them. */
15809 part_die
->name
= DW_STRING (&attr
);
15813 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
15814 &objfile
->per_bfd
->storage_obstack
);
15818 case DW_AT_linkage_name
:
15819 case DW_AT_MIPS_linkage_name
:
15820 /* Note that both forms of linkage name might appear. We
15821 assume they will be the same, and we only store the last
15823 if (cu
->language
== language_ada
)
15824 part_die
->name
= DW_STRING (&attr
);
15825 part_die
->linkage_name
= DW_STRING (&attr
);
15828 has_low_pc_attr
= 1;
15829 part_die
->lowpc
= attr_value_as_address (&attr
);
15831 case DW_AT_high_pc
:
15832 has_high_pc_attr
= 1;
15833 part_die
->highpc
= attr_value_as_address (&attr
);
15834 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
15835 high_pc_relative
= 1;
15837 case DW_AT_location
:
15838 /* Support the .debug_loc offsets. */
15839 if (attr_form_is_block (&attr
))
15841 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
15843 else if (attr_form_is_section_offset (&attr
))
15845 dwarf2_complex_location_expr_complaint ();
15849 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15850 "partial symbol information");
15853 case DW_AT_external
:
15854 part_die
->is_external
= DW_UNSND (&attr
);
15856 case DW_AT_declaration
:
15857 part_die
->is_declaration
= DW_UNSND (&attr
);
15860 part_die
->has_type
= 1;
15862 case DW_AT_abstract_origin
:
15863 case DW_AT_specification
:
15864 case DW_AT_extension
:
15865 part_die
->has_specification
= 1;
15866 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
15867 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15868 || cu
->per_cu
->is_dwz
);
15870 case DW_AT_sibling
:
15871 /* Ignore absolute siblings, they might point outside of
15872 the current compile unit. */
15873 if (attr
.form
== DW_FORM_ref_addr
)
15874 complaint (&symfile_complaints
,
15875 _("ignoring absolute DW_AT_sibling"));
15878 unsigned int off
= dwarf2_get_ref_die_offset (&attr
).sect_off
;
15879 const gdb_byte
*sibling_ptr
= buffer
+ off
;
15881 if (sibling_ptr
< info_ptr
)
15882 complaint (&symfile_complaints
,
15883 _("DW_AT_sibling points backwards"));
15884 else if (sibling_ptr
> reader
->buffer_end
)
15885 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
15887 part_die
->sibling
= sibling_ptr
;
15890 case DW_AT_byte_size
:
15891 part_die
->has_byte_size
= 1;
15893 case DW_AT_const_value
:
15894 part_die
->has_const_value
= 1;
15896 case DW_AT_calling_convention
:
15897 /* DWARF doesn't provide a way to identify a program's source-level
15898 entry point. DW_AT_calling_convention attributes are only meant
15899 to describe functions' calling conventions.
15901 However, because it's a necessary piece of information in
15902 Fortran, and because DW_CC_program is the only piece of debugging
15903 information whose definition refers to a 'main program' at all,
15904 several compilers have begun marking Fortran main programs with
15905 DW_CC_program --- even when those functions use the standard
15906 calling conventions.
15908 So until DWARF specifies a way to provide this information and
15909 compilers pick up the new representation, we'll support this
15911 if (DW_UNSND (&attr
) == DW_CC_program
15912 && cu
->language
== language_fortran
)
15913 set_objfile_main_name (objfile
, part_die
->name
, language_fortran
);
15916 if (DW_UNSND (&attr
) == DW_INL_inlined
15917 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
15918 part_die
->may_be_inlined
= 1;
15922 if (part_die
->tag
== DW_TAG_imported_unit
)
15924 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
15925 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
15926 || cu
->per_cu
->is_dwz
);
15935 if (high_pc_relative
)
15936 part_die
->highpc
+= part_die
->lowpc
;
15938 if (has_low_pc_attr
&& has_high_pc_attr
)
15940 /* When using the GNU linker, .gnu.linkonce. sections are used to
15941 eliminate duplicate copies of functions and vtables and such.
15942 The linker will arbitrarily choose one and discard the others.
15943 The AT_*_pc values for such functions refer to local labels in
15944 these sections. If the section from that file was discarded, the
15945 labels are not in the output, so the relocs get a value of 0.
15946 If this is a discarded function, mark the pc bounds as invalid,
15947 so that GDB will ignore it. */
15948 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
15950 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15952 complaint (&symfile_complaints
,
15953 _("DW_AT_low_pc %s is zero "
15954 "for DIE at 0x%x [in module %s]"),
15955 paddress (gdbarch
, part_die
->lowpc
),
15956 part_die
->offset
.sect_off
, objfile_name (objfile
));
15958 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15959 else if (part_die
->lowpc
>= part_die
->highpc
)
15961 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15963 complaint (&symfile_complaints
,
15964 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15965 "for DIE at 0x%x [in module %s]"),
15966 paddress (gdbarch
, part_die
->lowpc
),
15967 paddress (gdbarch
, part_die
->highpc
),
15968 part_die
->offset
.sect_off
, objfile_name (objfile
));
15971 part_die
->has_pc_info
= 1;
15977 /* Find a cached partial DIE at OFFSET in CU. */
15979 static struct partial_die_info
*
15980 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
15982 struct partial_die_info
*lookup_die
= NULL
;
15983 struct partial_die_info part_die
;
15985 part_die
.offset
= offset
;
15986 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
15992 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15993 except in the case of .debug_types DIEs which do not reference
15994 outside their CU (they do however referencing other types via
15995 DW_FORM_ref_sig8). */
15997 static struct partial_die_info
*
15998 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
16000 struct objfile
*objfile
= cu
->objfile
;
16001 struct dwarf2_per_cu_data
*per_cu
= NULL
;
16002 struct partial_die_info
*pd
= NULL
;
16004 if (offset_in_dwz
== cu
->per_cu
->is_dwz
16005 && offset_in_cu_p (&cu
->header
, offset
))
16007 pd
= find_partial_die_in_comp_unit (offset
, cu
);
16010 /* We missed recording what we needed.
16011 Load all dies and try again. */
16012 per_cu
= cu
->per_cu
;
16016 /* TUs don't reference other CUs/TUs (except via type signatures). */
16017 if (cu
->per_cu
->is_debug_types
)
16019 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
16020 " external reference to offset 0x%lx [in module %s].\n"),
16021 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
16022 bfd_get_filename (objfile
->obfd
));
16024 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
16027 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
16028 load_partial_comp_unit (per_cu
);
16030 per_cu
->cu
->last_used
= 0;
16031 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16034 /* If we didn't find it, and not all dies have been loaded,
16035 load them all and try again. */
16037 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
16039 per_cu
->load_all_dies
= 1;
16041 /* This is nasty. When we reread the DIEs, somewhere up the call chain
16042 THIS_CU->cu may already be in use. So we can't just free it and
16043 replace its DIEs with the ones we read in. Instead, we leave those
16044 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
16045 and clobber THIS_CU->cu->partial_dies with the hash table for the new
16047 load_partial_comp_unit (per_cu
);
16049 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
16053 internal_error (__FILE__
, __LINE__
,
16054 _("could not find partial DIE 0x%x "
16055 "in cache [from module %s]\n"),
16056 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
16060 /* See if we can figure out if the class lives in a namespace. We do
16061 this by looking for a member function; its demangled name will
16062 contain namespace info, if there is any. */
16065 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
16066 struct dwarf2_cu
*cu
)
16068 /* NOTE: carlton/2003-10-07: Getting the info this way changes
16069 what template types look like, because the demangler
16070 frequently doesn't give the same name as the debug info. We
16071 could fix this by only using the demangled name to get the
16072 prefix (but see comment in read_structure_type). */
16074 struct partial_die_info
*real_pdi
;
16075 struct partial_die_info
*child_pdi
;
16077 /* If this DIE (this DIE's specification, if any) has a parent, then
16078 we should not do this. We'll prepend the parent's fully qualified
16079 name when we create the partial symbol. */
16081 real_pdi
= struct_pdi
;
16082 while (real_pdi
->has_specification
)
16083 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
16084 real_pdi
->spec_is_dwz
, cu
);
16086 if (real_pdi
->die_parent
!= NULL
)
16089 for (child_pdi
= struct_pdi
->die_child
;
16091 child_pdi
= child_pdi
->die_sibling
)
16093 if (child_pdi
->tag
== DW_TAG_subprogram
16094 && child_pdi
->linkage_name
!= NULL
)
16096 char *actual_class_name
16097 = language_class_name_from_physname (cu
->language_defn
,
16098 child_pdi
->linkage_name
);
16099 if (actual_class_name
!= NULL
)
16102 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16104 strlen (actual_class_name
));
16105 xfree (actual_class_name
);
16112 /* Adjust PART_DIE before generating a symbol for it. This function
16113 may set the is_external flag or change the DIE's name. */
16116 fixup_partial_die (struct partial_die_info
*part_die
,
16117 struct dwarf2_cu
*cu
)
16119 /* Once we've fixed up a die, there's no point in doing so again.
16120 This also avoids a memory leak if we were to call
16121 guess_partial_die_structure_name multiple times. */
16122 if (part_die
->fixup_called
)
16125 /* If we found a reference attribute and the DIE has no name, try
16126 to find a name in the referred to DIE. */
16128 if (part_die
->name
== NULL
&& part_die
->has_specification
)
16130 struct partial_die_info
*spec_die
;
16132 spec_die
= find_partial_die (part_die
->spec_offset
,
16133 part_die
->spec_is_dwz
, cu
);
16135 fixup_partial_die (spec_die
, cu
);
16137 if (spec_die
->name
)
16139 part_die
->name
= spec_die
->name
;
16141 /* Copy DW_AT_external attribute if it is set. */
16142 if (spec_die
->is_external
)
16143 part_die
->is_external
= spec_die
->is_external
;
16147 /* Set default names for some unnamed DIEs. */
16149 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
16150 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
16152 /* If there is no parent die to provide a namespace, and there are
16153 children, see if we can determine the namespace from their linkage
16155 if (cu
->language
== language_cplus
16156 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
16157 && part_die
->die_parent
== NULL
16158 && part_die
->has_children
16159 && (part_die
->tag
== DW_TAG_class_type
16160 || part_die
->tag
== DW_TAG_structure_type
16161 || part_die
->tag
== DW_TAG_union_type
))
16162 guess_partial_die_structure_name (part_die
, cu
);
16164 /* GCC might emit a nameless struct or union that has a linkage
16165 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16166 if (part_die
->name
== NULL
16167 && (part_die
->tag
== DW_TAG_class_type
16168 || part_die
->tag
== DW_TAG_interface_type
16169 || part_die
->tag
== DW_TAG_structure_type
16170 || part_die
->tag
== DW_TAG_union_type
)
16171 && part_die
->linkage_name
!= NULL
)
16175 demangled
= gdb_demangle (part_die
->linkage_name
, DMGL_TYPES
);
16180 /* Strip any leading namespaces/classes, keep only the base name.
16181 DW_AT_name for named DIEs does not contain the prefixes. */
16182 base
= strrchr (demangled
, ':');
16183 if (base
&& base
> demangled
&& base
[-1] == ':')
16189 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
16190 base
, strlen (base
));
16195 part_die
->fixup_called
= 1;
16198 /* Read an attribute value described by an attribute form. */
16200 static const gdb_byte
*
16201 read_attribute_value (const struct die_reader_specs
*reader
,
16202 struct attribute
*attr
, unsigned form
,
16203 const gdb_byte
*info_ptr
)
16205 struct dwarf2_cu
*cu
= reader
->cu
;
16206 struct objfile
*objfile
= cu
->objfile
;
16207 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16208 bfd
*abfd
= reader
->abfd
;
16209 struct comp_unit_head
*cu_header
= &cu
->header
;
16210 unsigned int bytes_read
;
16211 struct dwarf_block
*blk
;
16216 case DW_FORM_ref_addr
:
16217 if (cu
->header
.version
== 2)
16218 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16220 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
16221 &cu
->header
, &bytes_read
);
16222 info_ptr
+= bytes_read
;
16224 case DW_FORM_GNU_ref_alt
:
16225 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16226 info_ptr
+= bytes_read
;
16229 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
16230 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
16231 info_ptr
+= bytes_read
;
16233 case DW_FORM_block2
:
16234 blk
= dwarf_alloc_block (cu
);
16235 blk
->size
= read_2_bytes (abfd
, info_ptr
);
16237 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16238 info_ptr
+= blk
->size
;
16239 DW_BLOCK (attr
) = blk
;
16241 case DW_FORM_block4
:
16242 blk
= dwarf_alloc_block (cu
);
16243 blk
->size
= read_4_bytes (abfd
, info_ptr
);
16245 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16246 info_ptr
+= blk
->size
;
16247 DW_BLOCK (attr
) = blk
;
16249 case DW_FORM_data2
:
16250 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
16253 case DW_FORM_data4
:
16254 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
16257 case DW_FORM_data8
:
16258 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
16261 case DW_FORM_sec_offset
:
16262 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
16263 info_ptr
+= bytes_read
;
16265 case DW_FORM_string
:
16266 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
16267 DW_STRING_IS_CANONICAL (attr
) = 0;
16268 info_ptr
+= bytes_read
;
16271 if (!cu
->per_cu
->is_dwz
)
16273 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
16275 DW_STRING_IS_CANONICAL (attr
) = 0;
16276 info_ptr
+= bytes_read
;
16280 case DW_FORM_GNU_strp_alt
:
16282 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
16283 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
16286 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
16287 DW_STRING_IS_CANONICAL (attr
) = 0;
16288 info_ptr
+= bytes_read
;
16291 case DW_FORM_exprloc
:
16292 case DW_FORM_block
:
16293 blk
= dwarf_alloc_block (cu
);
16294 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16295 info_ptr
+= bytes_read
;
16296 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16297 info_ptr
+= blk
->size
;
16298 DW_BLOCK (attr
) = blk
;
16300 case DW_FORM_block1
:
16301 blk
= dwarf_alloc_block (cu
);
16302 blk
->size
= read_1_byte (abfd
, info_ptr
);
16304 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
16305 info_ptr
+= blk
->size
;
16306 DW_BLOCK (attr
) = blk
;
16308 case DW_FORM_data1
:
16309 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16313 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
16316 case DW_FORM_flag_present
:
16317 DW_UNSND (attr
) = 1;
16319 case DW_FORM_sdata
:
16320 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
16321 info_ptr
+= bytes_read
;
16323 case DW_FORM_udata
:
16324 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16325 info_ptr
+= bytes_read
;
16328 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16329 + read_1_byte (abfd
, info_ptr
));
16333 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16334 + read_2_bytes (abfd
, info_ptr
));
16338 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16339 + read_4_bytes (abfd
, info_ptr
));
16343 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16344 + read_8_bytes (abfd
, info_ptr
));
16347 case DW_FORM_ref_sig8
:
16348 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
16351 case DW_FORM_ref_udata
:
16352 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
16353 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
16354 info_ptr
+= bytes_read
;
16356 case DW_FORM_indirect
:
16357 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16358 info_ptr
+= bytes_read
;
16359 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
16361 case DW_FORM_GNU_addr_index
:
16362 if (reader
->dwo_file
== NULL
)
16364 /* For now flag a hard error.
16365 Later we can turn this into a complaint. */
16366 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16367 dwarf_form_name (form
),
16368 bfd_get_filename (abfd
));
16370 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
16371 info_ptr
+= bytes_read
;
16373 case DW_FORM_GNU_str_index
:
16374 if (reader
->dwo_file
== NULL
)
16376 /* For now flag a hard error.
16377 Later we can turn this into a complaint if warranted. */
16378 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16379 dwarf_form_name (form
),
16380 bfd_get_filename (abfd
));
16383 ULONGEST str_index
=
16384 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
16386 DW_STRING (attr
) = read_str_index (reader
, str_index
);
16387 DW_STRING_IS_CANONICAL (attr
) = 0;
16388 info_ptr
+= bytes_read
;
16392 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16393 dwarf_form_name (form
),
16394 bfd_get_filename (abfd
));
16398 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
16399 attr
->form
= DW_FORM_GNU_ref_alt
;
16401 /* We have seen instances where the compiler tried to emit a byte
16402 size attribute of -1 which ended up being encoded as an unsigned
16403 0xffffffff. Although 0xffffffff is technically a valid size value,
16404 an object of this size seems pretty unlikely so we can relatively
16405 safely treat these cases as if the size attribute was invalid and
16406 treat them as zero by default. */
16407 if (attr
->name
== DW_AT_byte_size
16408 && form
== DW_FORM_data4
16409 && DW_UNSND (attr
) >= 0xffffffff)
16412 (&symfile_complaints
,
16413 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16414 hex_string (DW_UNSND (attr
)));
16415 DW_UNSND (attr
) = 0;
16421 /* Read an attribute described by an abbreviated attribute. */
16423 static const gdb_byte
*
16424 read_attribute (const struct die_reader_specs
*reader
,
16425 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
16426 const gdb_byte
*info_ptr
)
16428 attr
->name
= abbrev
->name
;
16429 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
16432 /* Read dwarf information from a buffer. */
16434 static unsigned int
16435 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
16437 return bfd_get_8 (abfd
, buf
);
16441 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
16443 return bfd_get_signed_8 (abfd
, buf
);
16446 static unsigned int
16447 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16449 return bfd_get_16 (abfd
, buf
);
16453 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16455 return bfd_get_signed_16 (abfd
, buf
);
16458 static unsigned int
16459 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16461 return bfd_get_32 (abfd
, buf
);
16465 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16467 return bfd_get_signed_32 (abfd
, buf
);
16471 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
16473 return bfd_get_64 (abfd
, buf
);
16477 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
16478 unsigned int *bytes_read
)
16480 struct comp_unit_head
*cu_header
= &cu
->header
;
16481 CORE_ADDR retval
= 0;
16483 if (cu_header
->signed_addr_p
)
16485 switch (cu_header
->addr_size
)
16488 retval
= bfd_get_signed_16 (abfd
, buf
);
16491 retval
= bfd_get_signed_32 (abfd
, buf
);
16494 retval
= bfd_get_signed_64 (abfd
, buf
);
16497 internal_error (__FILE__
, __LINE__
,
16498 _("read_address: bad switch, signed [in module %s]"),
16499 bfd_get_filename (abfd
));
16504 switch (cu_header
->addr_size
)
16507 retval
= bfd_get_16 (abfd
, buf
);
16510 retval
= bfd_get_32 (abfd
, buf
);
16513 retval
= bfd_get_64 (abfd
, buf
);
16516 internal_error (__FILE__
, __LINE__
,
16517 _("read_address: bad switch, "
16518 "unsigned [in module %s]"),
16519 bfd_get_filename (abfd
));
16523 *bytes_read
= cu_header
->addr_size
;
16527 /* Read the initial length from a section. The (draft) DWARF 3
16528 specification allows the initial length to take up either 4 bytes
16529 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16530 bytes describe the length and all offsets will be 8 bytes in length
16533 An older, non-standard 64-bit format is also handled by this
16534 function. The older format in question stores the initial length
16535 as an 8-byte quantity without an escape value. Lengths greater
16536 than 2^32 aren't very common which means that the initial 4 bytes
16537 is almost always zero. Since a length value of zero doesn't make
16538 sense for the 32-bit format, this initial zero can be considered to
16539 be an escape value which indicates the presence of the older 64-bit
16540 format. As written, the code can't detect (old format) lengths
16541 greater than 4GB. If it becomes necessary to handle lengths
16542 somewhat larger than 4GB, we could allow other small values (such
16543 as the non-sensical values of 1, 2, and 3) to also be used as
16544 escape values indicating the presence of the old format.
16546 The value returned via bytes_read should be used to increment the
16547 relevant pointer after calling read_initial_length().
16549 [ Note: read_initial_length() and read_offset() are based on the
16550 document entitled "DWARF Debugging Information Format", revision
16551 3, draft 8, dated November 19, 2001. This document was obtained
16554 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16556 This document is only a draft and is subject to change. (So beware.)
16558 Details regarding the older, non-standard 64-bit format were
16559 determined empirically by examining 64-bit ELF files produced by
16560 the SGI toolchain on an IRIX 6.5 machine.
16562 - Kevin, July 16, 2002
16566 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
16568 LONGEST length
= bfd_get_32 (abfd
, buf
);
16570 if (length
== 0xffffffff)
16572 length
= bfd_get_64 (abfd
, buf
+ 4);
16575 else if (length
== 0)
16577 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16578 length
= bfd_get_64 (abfd
, buf
);
16589 /* Cover function for read_initial_length.
16590 Returns the length of the object at BUF, and stores the size of the
16591 initial length in *BYTES_READ and stores the size that offsets will be in
16593 If the initial length size is not equivalent to that specified in
16594 CU_HEADER then issue a complaint.
16595 This is useful when reading non-comp-unit headers. */
16598 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
16599 const struct comp_unit_head
*cu_header
,
16600 unsigned int *bytes_read
,
16601 unsigned int *offset_size
)
16603 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
16605 gdb_assert (cu_header
->initial_length_size
== 4
16606 || cu_header
->initial_length_size
== 8
16607 || cu_header
->initial_length_size
== 12);
16609 if (cu_header
->initial_length_size
!= *bytes_read
)
16610 complaint (&symfile_complaints
,
16611 _("intermixed 32-bit and 64-bit DWARF sections"));
16613 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
16617 /* Read an offset from the data stream. The size of the offset is
16618 given by cu_header->offset_size. */
16621 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
16622 const struct comp_unit_head
*cu_header
,
16623 unsigned int *bytes_read
)
16625 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
16627 *bytes_read
= cu_header
->offset_size
;
16631 /* Read an offset from the data stream. */
16634 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
16636 LONGEST retval
= 0;
16638 switch (offset_size
)
16641 retval
= bfd_get_32 (abfd
, buf
);
16644 retval
= bfd_get_64 (abfd
, buf
);
16647 internal_error (__FILE__
, __LINE__
,
16648 _("read_offset_1: bad switch [in module %s]"),
16649 bfd_get_filename (abfd
));
16655 static const gdb_byte
*
16656 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
16658 /* If the size of a host char is 8 bits, we can return a pointer
16659 to the buffer, otherwise we have to copy the data to a buffer
16660 allocated on the temporary obstack. */
16661 gdb_assert (HOST_CHAR_BIT
== 8);
16665 static const char *
16666 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
16667 unsigned int *bytes_read_ptr
)
16669 /* If the size of a host char is 8 bits, we can return a pointer
16670 to the string, otherwise we have to copy the string to a buffer
16671 allocated on the temporary obstack. */
16672 gdb_assert (HOST_CHAR_BIT
== 8);
16675 *bytes_read_ptr
= 1;
16678 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
16679 return (const char *) buf
;
16682 static const char *
16683 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
16685 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
16686 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
16687 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16688 bfd_get_filename (abfd
));
16689 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
16690 error (_("DW_FORM_strp pointing outside of "
16691 ".debug_str section [in module %s]"),
16692 bfd_get_filename (abfd
));
16693 gdb_assert (HOST_CHAR_BIT
== 8);
16694 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
16696 return (const char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
16699 /* Read a string at offset STR_OFFSET in the .debug_str section from
16700 the .dwz file DWZ. Throw an error if the offset is too large. If
16701 the string consists of a single NUL byte, return NULL; otherwise
16702 return a pointer to the string. */
16704 static const char *
16705 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
16707 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
16709 if (dwz
->str
.buffer
== NULL
)
16710 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16711 "section [in module %s]"),
16712 bfd_get_filename (dwz
->dwz_bfd
));
16713 if (str_offset
>= dwz
->str
.size
)
16714 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16715 ".debug_str section [in module %s]"),
16716 bfd_get_filename (dwz
->dwz_bfd
));
16717 gdb_assert (HOST_CHAR_BIT
== 8);
16718 if (dwz
->str
.buffer
[str_offset
] == '\0')
16720 return (const char *) (dwz
->str
.buffer
+ str_offset
);
16723 static const char *
16724 read_indirect_string (bfd
*abfd
, const gdb_byte
*buf
,
16725 const struct comp_unit_head
*cu_header
,
16726 unsigned int *bytes_read_ptr
)
16728 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
16730 return read_indirect_string_at_offset (abfd
, str_offset
);
16734 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16735 unsigned int *bytes_read_ptr
)
16738 unsigned int num_read
;
16740 unsigned char byte
;
16748 byte
= bfd_get_8 (abfd
, buf
);
16751 result
|= ((ULONGEST
) (byte
& 127) << shift
);
16752 if ((byte
& 128) == 0)
16758 *bytes_read_ptr
= num_read
;
16763 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
16764 unsigned int *bytes_read_ptr
)
16767 int i
, shift
, num_read
;
16768 unsigned char byte
;
16776 byte
= bfd_get_8 (abfd
, buf
);
16779 result
|= ((LONGEST
) (byte
& 127) << shift
);
16781 if ((byte
& 128) == 0)
16786 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
16787 result
|= -(((LONGEST
) 1) << shift
);
16788 *bytes_read_ptr
= num_read
;
16792 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16793 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16794 ADDR_SIZE is the size of addresses from the CU header. */
16797 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
16799 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16800 bfd
*abfd
= objfile
->obfd
;
16801 const gdb_byte
*info_ptr
;
16803 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
16804 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
16805 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16806 objfile_name (objfile
));
16807 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
16808 error (_("DW_FORM_addr_index pointing outside of "
16809 ".debug_addr section [in module %s]"),
16810 objfile_name (objfile
));
16811 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
16812 + addr_base
+ addr_index
* addr_size
);
16813 if (addr_size
== 4)
16814 return bfd_get_32 (abfd
, info_ptr
);
16816 return bfd_get_64 (abfd
, info_ptr
);
16819 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16822 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
16824 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
16827 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16830 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
16831 unsigned int *bytes_read
)
16833 bfd
*abfd
= cu
->objfile
->obfd
;
16834 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
16836 return read_addr_index (cu
, addr_index
);
16839 /* Data structure to pass results from dwarf2_read_addr_index_reader
16840 back to dwarf2_read_addr_index. */
16842 struct dwarf2_read_addr_index_data
16844 ULONGEST addr_base
;
16848 /* die_reader_func for dwarf2_read_addr_index. */
16851 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
16852 const gdb_byte
*info_ptr
,
16853 struct die_info
*comp_unit_die
,
16857 struct dwarf2_cu
*cu
= reader
->cu
;
16858 struct dwarf2_read_addr_index_data
*aidata
=
16859 (struct dwarf2_read_addr_index_data
*) data
;
16861 aidata
->addr_base
= cu
->addr_base
;
16862 aidata
->addr_size
= cu
->header
.addr_size
;
16865 /* Given an index in .debug_addr, fetch the value.
16866 NOTE: This can be called during dwarf expression evaluation,
16867 long after the debug information has been read, and thus per_cu->cu
16868 may no longer exist. */
16871 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
16872 unsigned int addr_index
)
16874 struct objfile
*objfile
= per_cu
->objfile
;
16875 struct dwarf2_cu
*cu
= per_cu
->cu
;
16876 ULONGEST addr_base
;
16879 /* This is intended to be called from outside this file. */
16880 dw2_setup (objfile
);
16882 /* We need addr_base and addr_size.
16883 If we don't have PER_CU->cu, we have to get it.
16884 Nasty, but the alternative is storing the needed info in PER_CU,
16885 which at this point doesn't seem justified: it's not clear how frequently
16886 it would get used and it would increase the size of every PER_CU.
16887 Entry points like dwarf2_per_cu_addr_size do a similar thing
16888 so we're not in uncharted territory here.
16889 Alas we need to be a bit more complicated as addr_base is contained
16892 We don't need to read the entire CU(/TU).
16893 We just need the header and top level die.
16895 IWBN to use the aging mechanism to let us lazily later discard the CU.
16896 For now we skip this optimization. */
16900 addr_base
= cu
->addr_base
;
16901 addr_size
= cu
->header
.addr_size
;
16905 struct dwarf2_read_addr_index_data aidata
;
16907 /* Note: We can't use init_cutu_and_read_dies_simple here,
16908 we need addr_base. */
16909 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
16910 dwarf2_read_addr_index_reader
, &aidata
);
16911 addr_base
= aidata
.addr_base
;
16912 addr_size
= aidata
.addr_size
;
16915 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
16918 /* Given a DW_FORM_GNU_str_index, fetch the string.
16919 This is only used by the Fission support. */
16921 static const char *
16922 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
16924 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16925 const char *objf_name
= objfile_name (objfile
);
16926 bfd
*abfd
= objfile
->obfd
;
16927 struct dwarf2_cu
*cu
= reader
->cu
;
16928 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
16929 struct dwarf2_section_info
*str_offsets_section
=
16930 &reader
->dwo_file
->sections
.str_offsets
;
16931 const gdb_byte
*info_ptr
;
16932 ULONGEST str_offset
;
16933 static const char form_name
[] = "DW_FORM_GNU_str_index";
16935 dwarf2_read_section (objfile
, str_section
);
16936 dwarf2_read_section (objfile
, str_offsets_section
);
16937 if (str_section
->buffer
== NULL
)
16938 error (_("%s used without .debug_str.dwo section"
16939 " in CU at offset 0x%lx [in module %s]"),
16940 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16941 if (str_offsets_section
->buffer
== NULL
)
16942 error (_("%s used without .debug_str_offsets.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_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
16946 error (_("%s pointing outside of .debug_str_offsets.dwo"
16947 " section in CU at offset 0x%lx [in module %s]"),
16948 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16949 info_ptr
= (str_offsets_section
->buffer
16950 + str_index
* cu
->header
.offset_size
);
16951 if (cu
->header
.offset_size
== 4)
16952 str_offset
= bfd_get_32 (abfd
, info_ptr
);
16954 str_offset
= bfd_get_64 (abfd
, info_ptr
);
16955 if (str_offset
>= str_section
->size
)
16956 error (_("Offset from %s pointing outside of"
16957 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16958 form_name
, (long) cu
->header
.offset
.sect_off
, objf_name
);
16959 return (const char *) (str_section
->buffer
+ str_offset
);
16962 /* Return the length of an LEB128 number in BUF. */
16965 leb128_size (const gdb_byte
*buf
)
16967 const gdb_byte
*begin
= buf
;
16973 if ((byte
& 128) == 0)
16974 return buf
- begin
;
16979 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
16988 cu
->language
= language_c
;
16990 case DW_LANG_C_plus_plus
:
16991 case DW_LANG_C_plus_plus_11
:
16992 case DW_LANG_C_plus_plus_14
:
16993 cu
->language
= language_cplus
;
16996 cu
->language
= language_d
;
16998 case DW_LANG_Fortran77
:
16999 case DW_LANG_Fortran90
:
17000 case DW_LANG_Fortran95
:
17001 case DW_LANG_Fortran03
:
17002 case DW_LANG_Fortran08
:
17003 cu
->language
= language_fortran
;
17006 cu
->language
= language_go
;
17008 case DW_LANG_Mips_Assembler
:
17009 cu
->language
= language_asm
;
17012 cu
->language
= language_java
;
17014 case DW_LANG_Ada83
:
17015 case DW_LANG_Ada95
:
17016 cu
->language
= language_ada
;
17018 case DW_LANG_Modula2
:
17019 cu
->language
= language_m2
;
17021 case DW_LANG_Pascal83
:
17022 cu
->language
= language_pascal
;
17025 cu
->language
= language_objc
;
17027 case DW_LANG_Cobol74
:
17028 case DW_LANG_Cobol85
:
17030 cu
->language
= language_minimal
;
17033 cu
->language_defn
= language_def (cu
->language
);
17036 /* Return the named attribute or NULL if not there. */
17038 static struct attribute
*
17039 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
17044 struct attribute
*spec
= NULL
;
17046 for (i
= 0; i
< die
->num_attrs
; ++i
)
17048 if (die
->attrs
[i
].name
== name
)
17049 return &die
->attrs
[i
];
17050 if (die
->attrs
[i
].name
== DW_AT_specification
17051 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
17052 spec
= &die
->attrs
[i
];
17058 die
= follow_die_ref (die
, spec
, &cu
);
17064 /* Return the named attribute or NULL if not there,
17065 but do not follow DW_AT_specification, etc.
17066 This is for use in contexts where we're reading .debug_types dies.
17067 Following DW_AT_specification, DW_AT_abstract_origin will take us
17068 back up the chain, and we want to go down. */
17070 static struct attribute
*
17071 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
17075 for (i
= 0; i
< die
->num_attrs
; ++i
)
17076 if (die
->attrs
[i
].name
== name
)
17077 return &die
->attrs
[i
];
17082 /* Return non-zero iff the attribute NAME is defined for the given DIE,
17083 and holds a non-zero value. This function should only be used for
17084 DW_FORM_flag or DW_FORM_flag_present attributes. */
17087 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
17089 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
17091 return (attr
&& DW_UNSND (attr
));
17095 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
17097 /* A DIE is a declaration if it has a DW_AT_declaration attribute
17098 which value is non-zero. However, we have to be careful with
17099 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
17100 (via dwarf2_flag_true_p) follows this attribute. So we may
17101 end up accidently finding a declaration attribute that belongs
17102 to a different DIE referenced by the specification attribute,
17103 even though the given DIE does not have a declaration attribute. */
17104 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
17105 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
17108 /* Return the die giving the specification for DIE, if there is
17109 one. *SPEC_CU is the CU containing DIE on input, and the CU
17110 containing the return value on output. If there is no
17111 specification, but there is an abstract origin, that is
17114 static struct die_info
*
17115 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
17117 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
17120 if (spec_attr
== NULL
)
17121 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
17123 if (spec_attr
== NULL
)
17126 return follow_die_ref (die
, spec_attr
, spec_cu
);
17129 /* Free the line_header structure *LH, and any arrays and strings it
17131 NOTE: This is also used as a "cleanup" function. */
17134 free_line_header (struct line_header
*lh
)
17136 if (lh
->standard_opcode_lengths
)
17137 xfree (lh
->standard_opcode_lengths
);
17139 /* Remember that all the lh->file_names[i].name pointers are
17140 pointers into debug_line_buffer, and don't need to be freed. */
17141 if (lh
->file_names
)
17142 xfree (lh
->file_names
);
17144 /* Similarly for the include directory names. */
17145 if (lh
->include_dirs
)
17146 xfree (lh
->include_dirs
);
17151 /* Stub for free_line_header to match void * callback types. */
17154 free_line_header_voidp (void *arg
)
17156 struct line_header
*lh
= arg
;
17158 free_line_header (lh
);
17161 /* Add an entry to LH's include directory table. */
17164 add_include_dir (struct line_header
*lh
, const char *include_dir
)
17166 if (dwarf_line_debug
>= 2)
17167 fprintf_unfiltered (gdb_stdlog
, "Adding dir %u: %s\n",
17168 lh
->num_include_dirs
+ 1, include_dir
);
17170 /* Grow the array if necessary. */
17171 if (lh
->include_dirs_size
== 0)
17173 lh
->include_dirs_size
= 1; /* for testing */
17174 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
17175 * sizeof (*lh
->include_dirs
));
17177 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
17179 lh
->include_dirs_size
*= 2;
17180 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
17181 (lh
->include_dirs_size
17182 * sizeof (*lh
->include_dirs
)));
17185 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
17188 /* Add an entry to LH's file name table. */
17191 add_file_name (struct line_header
*lh
,
17193 unsigned int dir_index
,
17194 unsigned int mod_time
,
17195 unsigned int length
)
17197 struct file_entry
*fe
;
17199 if (dwarf_line_debug
>= 2)
17200 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
17201 lh
->num_file_names
+ 1, name
);
17203 /* Grow the array if necessary. */
17204 if (lh
->file_names_size
== 0)
17206 lh
->file_names_size
= 1; /* for testing */
17207 lh
->file_names
= xmalloc (lh
->file_names_size
17208 * sizeof (*lh
->file_names
));
17210 else if (lh
->num_file_names
>= lh
->file_names_size
)
17212 lh
->file_names_size
*= 2;
17213 lh
->file_names
= xrealloc (lh
->file_names
,
17214 (lh
->file_names_size
17215 * sizeof (*lh
->file_names
)));
17218 fe
= &lh
->file_names
[lh
->num_file_names
++];
17220 fe
->dir_index
= dir_index
;
17221 fe
->mod_time
= mod_time
;
17222 fe
->length
= length
;
17223 fe
->included_p
= 0;
17227 /* A convenience function to find the proper .debug_line section for a CU. */
17229 static struct dwarf2_section_info
*
17230 get_debug_line_section (struct dwarf2_cu
*cu
)
17232 struct dwarf2_section_info
*section
;
17234 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
17236 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17237 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
17238 else if (cu
->per_cu
->is_dwz
)
17240 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
17242 section
= &dwz
->line
;
17245 section
= &dwarf2_per_objfile
->line
;
17250 /* Read the statement program header starting at OFFSET in
17251 .debug_line, or .debug_line.dwo. Return a pointer
17252 to a struct line_header, allocated using xmalloc.
17253 Returns NULL if there is a problem reading the header, e.g., if it
17254 has a version we don't understand.
17256 NOTE: the strings in the include directory and file name tables of
17257 the returned object point into the dwarf line section buffer,
17258 and must not be freed. */
17260 static struct line_header
*
17261 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
17263 struct cleanup
*back_to
;
17264 struct line_header
*lh
;
17265 const gdb_byte
*line_ptr
;
17266 unsigned int bytes_read
, offset_size
;
17268 const char *cur_dir
, *cur_file
;
17269 struct dwarf2_section_info
*section
;
17272 section
= get_debug_line_section (cu
);
17273 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
17274 if (section
->buffer
== NULL
)
17276 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
17277 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
17279 complaint (&symfile_complaints
, _("missing .debug_line section"));
17283 /* We can't do this until we know the section is non-empty.
17284 Only then do we know we have such a section. */
17285 abfd
= get_section_bfd_owner (section
);
17287 /* Make sure that at least there's room for the total_length field.
17288 That could be 12 bytes long, but we're just going to fudge that. */
17289 if (offset
+ 4 >= section
->size
)
17291 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17295 lh
= xmalloc (sizeof (*lh
));
17296 memset (lh
, 0, sizeof (*lh
));
17297 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
17300 lh
->offset
.sect_off
= offset
;
17301 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
17303 line_ptr
= section
->buffer
+ offset
;
17305 /* Read in the header. */
17307 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
17308 &bytes_read
, &offset_size
);
17309 line_ptr
+= bytes_read
;
17310 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
17312 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17313 do_cleanups (back_to
);
17316 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
17317 lh
->version
= read_2_bytes (abfd
, line_ptr
);
17319 if (lh
->version
> 4)
17321 /* This is a version we don't understand. The format could have
17322 changed in ways we don't handle properly so just punt. */
17323 complaint (&symfile_complaints
,
17324 _("unsupported version in .debug_line section"));
17327 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
17328 line_ptr
+= offset_size
;
17329 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
17331 if (lh
->version
>= 4)
17333 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
17337 lh
->maximum_ops_per_instruction
= 1;
17339 if (lh
->maximum_ops_per_instruction
== 0)
17341 lh
->maximum_ops_per_instruction
= 1;
17342 complaint (&symfile_complaints
,
17343 _("invalid maximum_ops_per_instruction "
17344 "in `.debug_line' section"));
17347 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
17349 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
17351 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
17353 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
17355 lh
->standard_opcode_lengths
17356 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
17358 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
17359 for (i
= 1; i
< lh
->opcode_base
; ++i
)
17361 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
17365 /* Read directory table. */
17366 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17368 line_ptr
+= bytes_read
;
17369 add_include_dir (lh
, cur_dir
);
17371 line_ptr
+= bytes_read
;
17373 /* Read file name table. */
17374 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
17376 unsigned int dir_index
, mod_time
, length
;
17378 line_ptr
+= bytes_read
;
17379 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17380 line_ptr
+= bytes_read
;
17381 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17382 line_ptr
+= bytes_read
;
17383 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17384 line_ptr
+= bytes_read
;
17386 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17388 line_ptr
+= bytes_read
;
17389 lh
->statement_program_start
= line_ptr
;
17391 if (line_ptr
> (section
->buffer
+ section
->size
))
17392 complaint (&symfile_complaints
,
17393 _("line number info header doesn't "
17394 "fit in `.debug_line' section"));
17396 discard_cleanups (back_to
);
17400 /* Subroutine of dwarf_decode_lines to simplify it.
17401 Return the file name of the psymtab for included file FILE_INDEX
17402 in line header LH of PST.
17403 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17404 If space for the result is malloc'd, it will be freed by a cleanup.
17405 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17407 The function creates dangling cleanup registration. */
17409 static const char *
17410 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
17411 const struct partial_symtab
*pst
,
17412 const char *comp_dir
)
17414 const struct file_entry fe
= lh
->file_names
[file_index
];
17415 const char *include_name
= fe
.name
;
17416 const char *include_name_to_compare
= include_name
;
17417 const char *dir_name
= NULL
;
17418 const char *pst_filename
;
17419 char *copied_name
= NULL
;
17422 if (fe
.dir_index
&& lh
->include_dirs
!= NULL
)
17423 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
17425 if (!IS_ABSOLUTE_PATH (include_name
)
17426 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
17428 /* Avoid creating a duplicate psymtab for PST.
17429 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17430 Before we do the comparison, however, we need to account
17431 for DIR_NAME and COMP_DIR.
17432 First prepend dir_name (if non-NULL). If we still don't
17433 have an absolute path prepend comp_dir (if non-NULL).
17434 However, the directory we record in the include-file's
17435 psymtab does not contain COMP_DIR (to match the
17436 corresponding symtab(s)).
17441 bash$ gcc -g ./hello.c
17442 include_name = "hello.c"
17444 DW_AT_comp_dir = comp_dir = "/tmp"
17445 DW_AT_name = "./hello.c"
17449 if (dir_name
!= NULL
)
17451 char *tem
= concat (dir_name
, SLASH_STRING
,
17452 include_name
, (char *)NULL
);
17454 make_cleanup (xfree
, tem
);
17455 include_name
= tem
;
17456 include_name_to_compare
= include_name
;
17458 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
17460 char *tem
= concat (comp_dir
, SLASH_STRING
,
17461 include_name
, (char *)NULL
);
17463 make_cleanup (xfree
, tem
);
17464 include_name_to_compare
= tem
;
17468 pst_filename
= pst
->filename
;
17469 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
17471 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
17472 pst_filename
, (char *)NULL
);
17473 pst_filename
= copied_name
;
17476 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
17478 if (copied_name
!= NULL
)
17479 xfree (copied_name
);
17483 return include_name
;
17486 /* State machine to track the state of the line number program. */
17490 /* These are part of the standard DWARF line number state machine. */
17492 unsigned char op_index
;
17497 unsigned int discriminator
;
17499 /* Additional bits of state we need to track. */
17501 /* The last file that we called dwarf2_start_subfile for.
17502 This is only used for TLLs. */
17503 unsigned int last_file
;
17504 /* The last file a line number was recorded for. */
17505 struct subfile
*last_subfile
;
17507 /* The function to call to record a line. */
17508 record_line_ftype
*record_line
;
17510 /* The last line number that was recorded, used to coalesce
17511 consecutive entries for the same line. This can happen, for
17512 example, when discriminators are present. PR 17276. */
17513 unsigned int last_line
;
17514 int line_has_non_zero_discriminator
;
17515 } lnp_state_machine
;
17517 /* There's a lot of static state to pass to dwarf_record_line.
17518 This keeps it all together. */
17523 struct gdbarch
*gdbarch
;
17525 /* The line number header. */
17526 struct line_header
*line_header
;
17528 /* Non-zero if we're recording lines.
17529 Otherwise we're building partial symtabs and are just interested in
17530 finding include files mentioned by the line number program. */
17531 int record_lines_p
;
17532 } lnp_reader_state
;
17534 /* Ignore this record_line request. */
17537 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
17542 /* Return non-zero if we should add LINE to the line number table.
17543 LINE is the line to add, LAST_LINE is the last line that was added,
17544 LAST_SUBFILE is the subfile for LAST_LINE.
17545 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17546 had a non-zero discriminator.
17548 We have to be careful in the presence of discriminators.
17549 E.g., for this line:
17551 for (i = 0; i < 100000; i++);
17553 clang can emit four line number entries for that one line,
17554 each with a different discriminator.
17555 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17557 However, we want gdb to coalesce all four entries into one.
17558 Otherwise the user could stepi into the middle of the line and
17559 gdb would get confused about whether the pc really was in the
17560 middle of the line.
17562 Things are further complicated by the fact that two consecutive
17563 line number entries for the same line is a heuristic used by gcc
17564 to denote the end of the prologue. So we can't just discard duplicate
17565 entries, we have to be selective about it. The heuristic we use is
17566 that we only collapse consecutive entries for the same line if at least
17567 one of those entries has a non-zero discriminator. PR 17276.
17569 Note: Addresses in the line number state machine can never go backwards
17570 within one sequence, thus this coalescing is ok. */
17573 dwarf_record_line_p (unsigned int line
, unsigned int last_line
,
17574 int line_has_non_zero_discriminator
,
17575 struct subfile
*last_subfile
)
17577 if (current_subfile
!= last_subfile
)
17579 if (line
!= last_line
)
17581 /* Same line for the same file that we've seen already.
17582 As a last check, for pr 17276, only record the line if the line
17583 has never had a non-zero discriminator. */
17584 if (!line_has_non_zero_discriminator
)
17589 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17590 in the line table of subfile SUBFILE. */
17593 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17594 unsigned int line
, CORE_ADDR address
,
17595 record_line_ftype p_record_line
)
17597 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
17599 if (dwarf_line_debug
)
17601 fprintf_unfiltered (gdb_stdlog
,
17602 "Recording line %u, file %s, address %s\n",
17603 line
, lbasename (subfile
->name
),
17604 paddress (gdbarch
, address
));
17607 (*p_record_line
) (subfile
, line
, addr
);
17610 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17611 Mark the end of a set of line number records.
17612 The arguments are the same as for dwarf_record_line_1.
17613 If SUBFILE is NULL the request is ignored. */
17616 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
17617 CORE_ADDR address
, record_line_ftype p_record_line
)
17619 if (subfile
== NULL
)
17622 if (dwarf_line_debug
)
17624 fprintf_unfiltered (gdb_stdlog
,
17625 "Finishing current line, file %s, address %s\n",
17626 lbasename (subfile
->name
),
17627 paddress (gdbarch
, address
));
17630 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, p_record_line
);
17633 /* Record the line in STATE.
17634 END_SEQUENCE is non-zero if we're processing the end of a sequence. */
17637 dwarf_record_line (lnp_reader_state
*reader
, lnp_state_machine
*state
,
17640 const struct line_header
*lh
= reader
->line_header
;
17641 unsigned int file
, line
, discriminator
;
17644 file
= state
->file
;
17645 line
= state
->line
;
17646 is_stmt
= state
->is_stmt
;
17647 discriminator
= state
->discriminator
;
17649 if (dwarf_line_debug
)
17651 fprintf_unfiltered (gdb_stdlog
,
17652 "Processing actual line %u: file %u,"
17653 " address %s, is_stmt %u, discrim %u\n",
17655 paddress (reader
->gdbarch
, state
->address
),
17656 is_stmt
, discriminator
);
17659 if (file
== 0 || file
- 1 >= lh
->num_file_names
)
17660 dwarf2_debug_line_missing_file_complaint ();
17661 /* For now we ignore lines not starting on an instruction boundary.
17662 But not when processing end_sequence for compatibility with the
17663 previous version of the code. */
17664 else if (state
->op_index
== 0 || end_sequence
)
17666 lh
->file_names
[file
- 1].included_p
= 1;
17667 if (reader
->record_lines_p
&& is_stmt
)
17669 if (state
->last_subfile
!= current_subfile
|| end_sequence
)
17671 dwarf_finish_line (reader
->gdbarch
, state
->last_subfile
,
17672 state
->address
, state
->record_line
);
17677 if (dwarf_record_line_p (line
, state
->last_line
,
17678 state
->line_has_non_zero_discriminator
,
17679 state
->last_subfile
))
17681 dwarf_record_line_1 (reader
->gdbarch
, current_subfile
,
17682 line
, state
->address
,
17683 state
->record_line
);
17685 state
->last_subfile
= current_subfile
;
17686 state
->last_line
= line
;
17692 /* Initialize STATE for the start of a line number program. */
17695 init_lnp_state_machine (lnp_state_machine
*state
,
17696 const lnp_reader_state
*reader
)
17698 memset (state
, 0, sizeof (*state
));
17700 /* Just starting, there is no "last file". */
17701 state
->last_file
= 0;
17702 state
->last_subfile
= NULL
;
17704 state
->record_line
= record_line
;
17706 state
->last_line
= 0;
17707 state
->line_has_non_zero_discriminator
= 0;
17709 /* Initialize these according to the DWARF spec. */
17710 state
->op_index
= 0;
17713 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
17714 was a line entry for it so that the backend has a chance to adjust it
17715 and also record it in case it needs it. This is currently used by MIPS
17716 code, cf. `mips_adjust_dwarf2_line'. */
17717 state
->address
= gdbarch_adjust_dwarf2_line (reader
->gdbarch
, 0, 0);
17718 state
->is_stmt
= reader
->line_header
->default_is_stmt
;
17719 state
->discriminator
= 0;
17722 /* Check address and if invalid nop-out the rest of the lines in this
17726 check_line_address (struct dwarf2_cu
*cu
, lnp_state_machine
*state
,
17727 const gdb_byte
*line_ptr
,
17728 CORE_ADDR lowpc
, CORE_ADDR address
)
17730 /* If address < lowpc then it's not a usable value, it's outside the
17731 pc range of the CU. However, we restrict the test to only address
17732 values of zero to preserve GDB's previous behaviour which is to
17733 handle the specific case of a function being GC'd by the linker. */
17735 if (address
== 0 && address
< lowpc
)
17737 /* This line table is for a function which has been
17738 GCd by the linker. Ignore it. PR gdb/12528 */
17740 struct objfile
*objfile
= cu
->objfile
;
17741 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
17743 complaint (&symfile_complaints
,
17744 _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
17745 line_offset
, objfile_name (objfile
));
17746 state
->record_line
= noop_record_line
;
17747 /* Note: sm.record_line is left as noop_record_line
17748 until we see DW_LNE_end_sequence. */
17752 /* Subroutine of dwarf_decode_lines to simplify it.
17753 Process the line number information in LH.
17754 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
17755 program in order to set included_p for every referenced header. */
17758 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
17759 const int decode_for_pst_p
, CORE_ADDR lowpc
)
17761 const gdb_byte
*line_ptr
, *extended_end
;
17762 const gdb_byte
*line_end
;
17763 unsigned int bytes_read
, extended_len
;
17764 unsigned char op_code
, extended_op
;
17765 CORE_ADDR baseaddr
;
17766 struct objfile
*objfile
= cu
->objfile
;
17767 bfd
*abfd
= objfile
->obfd
;
17768 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17769 /* Non-zero if we're recording line info (as opposed to building partial
17771 int record_lines_p
= !decode_for_pst_p
;
17772 /* A collection of things we need to pass to dwarf_record_line. */
17773 lnp_reader_state reader_state
;
17775 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
17777 line_ptr
= lh
->statement_program_start
;
17778 line_end
= lh
->statement_program_end
;
17780 reader_state
.gdbarch
= gdbarch
;
17781 reader_state
.line_header
= lh
;
17782 reader_state
.record_lines_p
= record_lines_p
;
17784 /* Read the statement sequences until there's nothing left. */
17785 while (line_ptr
< line_end
)
17787 /* The DWARF line number program state machine. */
17788 lnp_state_machine state_machine
;
17789 int end_sequence
= 0;
17791 /* Reset the state machine at the start of each sequence. */
17792 init_lnp_state_machine (&state_machine
, &reader_state
);
17794 if (record_lines_p
&& lh
->num_file_names
>= state_machine
.file
)
17796 /* Start a subfile for the current file of the state machine. */
17797 /* lh->include_dirs and lh->file_names are 0-based, but the
17798 directory and file name numbers in the statement program
17800 struct file_entry
*fe
= &lh
->file_names
[state_machine
.file
- 1];
17801 const char *dir
= NULL
;
17803 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
17804 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17806 dwarf2_start_subfile (fe
->name
, dir
);
17809 /* Decode the table. */
17810 while (line_ptr
< line_end
&& !end_sequence
)
17812 op_code
= read_1_byte (abfd
, line_ptr
);
17815 if (op_code
>= lh
->opcode_base
)
17817 /* Special opcode. */
17818 unsigned char adj_opcode
;
17819 CORE_ADDR addr_adj
;
17822 adj_opcode
= op_code
- lh
->opcode_base
;
17823 addr_adj
= (((state_machine
.op_index
17824 + (adj_opcode
/ lh
->line_range
))
17825 / lh
->maximum_ops_per_instruction
)
17826 * lh
->minimum_instruction_length
);
17827 state_machine
.address
17828 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17829 state_machine
.op_index
= ((state_machine
.op_index
17830 + (adj_opcode
/ lh
->line_range
))
17831 % lh
->maximum_ops_per_instruction
);
17832 line_delta
= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
17833 state_machine
.line
+= line_delta
;
17834 if (line_delta
!= 0)
17835 state_machine
.line_has_non_zero_discriminator
17836 = state_machine
.discriminator
!= 0;
17838 dwarf_record_line (&reader_state
, &state_machine
, 0);
17839 state_machine
.discriminator
= 0;
17841 else switch (op_code
)
17843 case DW_LNS_extended_op
:
17844 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
17846 line_ptr
+= bytes_read
;
17847 extended_end
= line_ptr
+ extended_len
;
17848 extended_op
= read_1_byte (abfd
, line_ptr
);
17850 switch (extended_op
)
17852 case DW_LNE_end_sequence
:
17853 state_machine
.record_line
= record_line
;
17856 case DW_LNE_set_address
:
17859 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
17861 line_ptr
+= bytes_read
;
17862 check_line_address (cu
, &state_machine
, line_ptr
,
17864 state_machine
.op_index
= 0;
17865 address
+= baseaddr
;
17866 state_machine
.address
17867 = gdbarch_adjust_dwarf2_line (gdbarch
, address
, 0);
17870 case DW_LNE_define_file
:
17872 const char *cur_file
;
17873 unsigned int dir_index
, mod_time
, length
;
17875 cur_file
= read_direct_string (abfd
, line_ptr
,
17877 line_ptr
+= bytes_read
;
17879 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17880 line_ptr
+= bytes_read
;
17882 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17883 line_ptr
+= bytes_read
;
17885 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17886 line_ptr
+= bytes_read
;
17887 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
17890 case DW_LNE_set_discriminator
:
17891 /* The discriminator is not interesting to the debugger;
17892 just ignore it. We still need to check its value though:
17893 if there are consecutive entries for the same
17894 (non-prologue) line we want to coalesce them.
17896 state_machine
.discriminator
17897 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17898 state_machine
.line_has_non_zero_discriminator
17899 |= state_machine
.discriminator
!= 0;
17900 line_ptr
+= bytes_read
;
17903 complaint (&symfile_complaints
,
17904 _("mangled .debug_line section"));
17907 /* Make sure that we parsed the extended op correctly. If e.g.
17908 we expected a different address size than the producer used,
17909 we may have read the wrong number of bytes. */
17910 if (line_ptr
!= extended_end
)
17912 complaint (&symfile_complaints
,
17913 _("mangled .debug_line section"));
17918 dwarf_record_line (&reader_state
, &state_machine
, 0);
17919 state_machine
.discriminator
= 0;
17921 case DW_LNS_advance_pc
:
17924 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17925 CORE_ADDR addr_adj
;
17927 addr_adj
= (((state_machine
.op_index
+ adjust
)
17928 / lh
->maximum_ops_per_instruction
)
17929 * lh
->minimum_instruction_length
);
17930 state_machine
.address
17931 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
17932 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
17933 % lh
->maximum_ops_per_instruction
);
17934 line_ptr
+= bytes_read
;
17937 case DW_LNS_advance_line
:
17940 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
17942 state_machine
.line
+= line_delta
;
17943 if (line_delta
!= 0)
17944 state_machine
.line_has_non_zero_discriminator
17945 = state_machine
.discriminator
!= 0;
17946 line_ptr
+= bytes_read
;
17949 case DW_LNS_set_file
:
17951 /* The arrays lh->include_dirs and lh->file_names are
17952 0-based, but the directory and file name numbers in
17953 the statement program are 1-based. */
17954 struct file_entry
*fe
;
17955 const char *dir
= NULL
;
17957 state_machine
.file
= read_unsigned_leb128 (abfd
, line_ptr
,
17959 line_ptr
+= bytes_read
;
17960 if (state_machine
.file
== 0
17961 || state_machine
.file
- 1 >= lh
->num_file_names
)
17962 dwarf2_debug_line_missing_file_complaint ();
17965 fe
= &lh
->file_names
[state_machine
.file
- 1];
17966 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
17967 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
17968 if (record_lines_p
)
17970 state_machine
.last_subfile
= current_subfile
;
17971 state_machine
.line_has_non_zero_discriminator
17972 = state_machine
.discriminator
!= 0;
17973 dwarf2_start_subfile (fe
->name
, dir
);
17978 case DW_LNS_set_column
:
17979 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
17980 line_ptr
+= bytes_read
;
17982 case DW_LNS_negate_stmt
:
17983 state_machine
.is_stmt
= (!state_machine
.is_stmt
);
17985 case DW_LNS_set_basic_block
:
17987 /* Add to the address register of the state machine the
17988 address increment value corresponding to special opcode
17989 255. I.e., this value is scaled by the minimum
17990 instruction length since special opcode 255 would have
17991 scaled the increment. */
17992 case DW_LNS_const_add_pc
:
17994 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
17995 CORE_ADDR addr_adj
;
17997 addr_adj
= (((state_machine
.op_index
+ adjust
)
17998 / lh
->maximum_ops_per_instruction
)
17999 * lh
->minimum_instruction_length
);
18000 state_machine
.address
18001 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18002 state_machine
.op_index
= ((state_machine
.op_index
+ adjust
)
18003 % lh
->maximum_ops_per_instruction
);
18006 case DW_LNS_fixed_advance_pc
:
18008 CORE_ADDR addr_adj
;
18010 addr_adj
= read_2_bytes (abfd
, line_ptr
);
18011 state_machine
.address
18012 += gdbarch_adjust_dwarf2_line (gdbarch
, addr_adj
, 1);
18013 state_machine
.op_index
= 0;
18019 /* Unknown standard opcode, ignore it. */
18022 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
18024 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
18025 line_ptr
+= bytes_read
;
18032 dwarf2_debug_line_missing_end_sequence_complaint ();
18034 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
18035 in which case we still finish recording the last line). */
18036 dwarf_record_line (&reader_state
, &state_machine
, 1);
18040 /* Decode the Line Number Program (LNP) for the given line_header
18041 structure and CU. The actual information extracted and the type
18042 of structures created from the LNP depends on the value of PST.
18044 1. If PST is NULL, then this procedure uses the data from the program
18045 to create all necessary symbol tables, and their linetables.
18047 2. If PST is not NULL, this procedure reads the program to determine
18048 the list of files included by the unit represented by PST, and
18049 builds all the associated partial symbol tables.
18051 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
18052 It is used for relative paths in the line table.
18053 NOTE: When processing partial symtabs (pst != NULL),
18054 comp_dir == pst->dirname.
18056 NOTE: It is important that psymtabs have the same file name (via strcmp)
18057 as the corresponding symtab. Since COMP_DIR is not used in the name of the
18058 symtab we don't use it in the name of the psymtabs we create.
18059 E.g. expand_line_sal requires this when finding psymtabs to expand.
18060 A good testcase for this is mb-inline.exp.
18062 LOWPC is the lowest address in CU (or 0 if not known).
18064 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
18065 for its PC<->lines mapping information. Otherwise only the filename
18066 table is read in. */
18069 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
18070 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
18071 CORE_ADDR lowpc
, int decode_mapping
)
18073 struct objfile
*objfile
= cu
->objfile
;
18074 const int decode_for_pst_p
= (pst
!= NULL
);
18076 if (decode_mapping
)
18077 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
18079 if (decode_for_pst_p
)
18083 /* Now that we're done scanning the Line Header Program, we can
18084 create the psymtab of each included file. */
18085 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
18086 if (lh
->file_names
[file_index
].included_p
== 1)
18088 const char *include_name
=
18089 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
18090 if (include_name
!= NULL
)
18091 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
18096 /* Make sure a symtab is created for every file, even files
18097 which contain only variables (i.e. no code with associated
18099 struct compunit_symtab
*cust
= buildsym_compunit_symtab ();
18102 for (i
= 0; i
< lh
->num_file_names
; i
++)
18104 const char *dir
= NULL
;
18105 struct file_entry
*fe
;
18107 fe
= &lh
->file_names
[i
];
18108 if (fe
->dir_index
&& lh
->include_dirs
!= NULL
)
18109 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
18110 dwarf2_start_subfile (fe
->name
, dir
);
18112 if (current_subfile
->symtab
== NULL
)
18114 current_subfile
->symtab
18115 = allocate_symtab (cust
, current_subfile
->name
);
18117 fe
->symtab
= current_subfile
->symtab
;
18122 /* Start a subfile for DWARF. FILENAME is the name of the file and
18123 DIRNAME the name of the source directory which contains FILENAME
18124 or NULL if not known.
18125 This routine tries to keep line numbers from identical absolute and
18126 relative file names in a common subfile.
18128 Using the `list' example from the GDB testsuite, which resides in
18129 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
18130 of /srcdir/list0.c yields the following debugging information for list0.c:
18132 DW_AT_name: /srcdir/list0.c
18133 DW_AT_comp_dir: /compdir
18134 files.files[0].name: list0.h
18135 files.files[0].dir: /srcdir
18136 files.files[1].name: list0.c
18137 files.files[1].dir: /srcdir
18139 The line number information for list0.c has to end up in a single
18140 subfile, so that `break /srcdir/list0.c:1' works as expected.
18141 start_subfile will ensure that this happens provided that we pass the
18142 concatenation of files.files[1].dir and files.files[1].name as the
18146 dwarf2_start_subfile (const char *filename
, const char *dirname
)
18150 /* In order not to lose the line information directory,
18151 we concatenate it to the filename when it makes sense.
18152 Note that the Dwarf3 standard says (speaking of filenames in line
18153 information): ``The directory index is ignored for file names
18154 that represent full path names''. Thus ignoring dirname in the
18155 `else' branch below isn't an issue. */
18157 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
18159 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
18163 start_subfile (filename
);
18169 /* Start a symtab for DWARF.
18170 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
18172 static struct compunit_symtab
*
18173 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
18174 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
18176 struct compunit_symtab
*cust
18177 = start_symtab (cu
->objfile
, name
, comp_dir
, low_pc
);
18179 record_debugformat ("DWARF 2");
18180 record_producer (cu
->producer
);
18182 /* We assume that we're processing GCC output. */
18183 processing_gcc_compilation
= 2;
18185 cu
->processing_has_namespace_info
= 0;
18191 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
18192 struct dwarf2_cu
*cu
)
18194 struct objfile
*objfile
= cu
->objfile
;
18195 struct comp_unit_head
*cu_header
= &cu
->header
;
18197 /* NOTE drow/2003-01-30: There used to be a comment and some special
18198 code here to turn a symbol with DW_AT_external and a
18199 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
18200 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
18201 with some versions of binutils) where shared libraries could have
18202 relocations against symbols in their debug information - the
18203 minimal symbol would have the right address, but the debug info
18204 would not. It's no longer necessary, because we will explicitly
18205 apply relocations when we read in the debug information now. */
18207 /* A DW_AT_location attribute with no contents indicates that a
18208 variable has been optimized away. */
18209 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
18211 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18215 /* Handle one degenerate form of location expression specially, to
18216 preserve GDB's previous behavior when section offsets are
18217 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
18218 then mark this symbol as LOC_STATIC. */
18220 if (attr_form_is_block (attr
)
18221 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
18222 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
18223 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
18224 && (DW_BLOCK (attr
)->size
18225 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
18227 unsigned int dummy
;
18229 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
18230 SYMBOL_VALUE_ADDRESS (sym
) =
18231 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
18233 SYMBOL_VALUE_ADDRESS (sym
) =
18234 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
18235 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
18236 fixup_symbol_section (sym
, objfile
);
18237 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
18238 SYMBOL_SECTION (sym
));
18242 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
18243 expression evaluator, and use LOC_COMPUTED only when necessary
18244 (i.e. when the value of a register or memory location is
18245 referenced, or a thread-local block, etc.). Then again, it might
18246 not be worthwhile. I'm assuming that it isn't unless performance
18247 or memory numbers show me otherwise. */
18249 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
18251 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
18252 cu
->has_loclist
= 1;
18255 /* Given a pointer to a DWARF information entry, figure out if we need
18256 to make a symbol table entry for it, and if so, create a new entry
18257 and return a pointer to it.
18258 If TYPE is NULL, determine symbol type from the die, otherwise
18259 used the passed type.
18260 If SPACE is not NULL, use it to hold the new symbol. If it is
18261 NULL, allocate a new symbol on the objfile's obstack. */
18263 static struct symbol
*
18264 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
18265 struct symbol
*space
)
18267 struct objfile
*objfile
= cu
->objfile
;
18268 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18269 struct symbol
*sym
= NULL
;
18271 struct attribute
*attr
= NULL
;
18272 struct attribute
*attr2
= NULL
;
18273 CORE_ADDR baseaddr
;
18274 struct pending
**list_to_add
= NULL
;
18276 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
18278 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
18280 name
= dwarf2_name (die
, cu
);
18283 const char *linkagename
;
18284 int suppress_add
= 0;
18289 sym
= allocate_symbol (objfile
);
18290 OBJSTAT (objfile
, n_syms
++);
18292 /* Cache this symbol's name and the name's demangled form (if any). */
18293 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
18294 linkagename
= dwarf2_physname (name
, die
, cu
);
18295 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
18297 /* Fortran does not have mangling standard and the mangling does differ
18298 between gfortran, iFort etc. */
18299 if (cu
->language
== language_fortran
18300 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
18301 symbol_set_demangled_name (&(sym
->ginfo
),
18302 dwarf2_full_name (name
, die
, cu
),
18305 /* Default assumptions.
18306 Use the passed type or decode it from the die. */
18307 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18308 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
18310 SYMBOL_TYPE (sym
) = type
;
18312 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
18313 attr
= dwarf2_attr (die
,
18314 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
18318 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
18321 attr
= dwarf2_attr (die
,
18322 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
18326 int file_index
= DW_UNSND (attr
);
18328 if (cu
->line_header
== NULL
18329 || file_index
> cu
->line_header
->num_file_names
)
18330 complaint (&symfile_complaints
,
18331 _("file index out of range"));
18332 else if (file_index
> 0)
18334 struct file_entry
*fe
;
18336 fe
= &cu
->line_header
->file_names
[file_index
- 1];
18337 symbol_set_symtab (sym
, fe
->symtab
);
18344 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
18349 addr
= attr_value_as_address (attr
);
18350 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
18351 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
18353 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
18354 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
18355 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
18356 add_symbol_to_list (sym
, cu
->list_in_scope
);
18358 case DW_TAG_subprogram
:
18359 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18361 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18362 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18363 if ((attr2
&& (DW_UNSND (attr2
) != 0))
18364 || cu
->language
== language_ada
)
18366 /* Subprograms marked external are stored as a global symbol.
18367 Ada subprograms, whether marked external or not, are always
18368 stored as a global symbol, because we want to be able to
18369 access them globally. For instance, we want to be able
18370 to break on a nested subprogram without having to
18371 specify the context. */
18372 list_to_add
= &global_symbols
;
18376 list_to_add
= cu
->list_in_scope
;
18379 case DW_TAG_inlined_subroutine
:
18380 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18382 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
18383 SYMBOL_INLINED (sym
) = 1;
18384 list_to_add
= cu
->list_in_scope
;
18386 case DW_TAG_template_value_param
:
18388 /* Fall through. */
18389 case DW_TAG_constant
:
18390 case DW_TAG_variable
:
18391 case DW_TAG_member
:
18392 /* Compilation with minimal debug info may result in
18393 variables with missing type entries. Change the
18394 misleading `void' type to something sensible. */
18395 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
18397 = objfile_type (objfile
)->nodebug_data_symbol
;
18399 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18400 /* In the case of DW_TAG_member, we should only be called for
18401 static const members. */
18402 if (die
->tag
== DW_TAG_member
)
18404 /* dwarf2_add_field uses die_is_declaration,
18405 so we do the same. */
18406 gdb_assert (die_is_declaration (die
, cu
));
18411 dwarf2_const_value (attr
, sym
, cu
);
18412 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18415 if (attr2
&& (DW_UNSND (attr2
) != 0))
18416 list_to_add
= &global_symbols
;
18418 list_to_add
= cu
->list_in_scope
;
18422 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18425 var_decode_location (attr
, sym
, cu
);
18426 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18428 /* Fortran explicitly imports any global symbols to the local
18429 scope by DW_TAG_common_block. */
18430 if (cu
->language
== language_fortran
&& die
->parent
18431 && die
->parent
->tag
== DW_TAG_common_block
)
18434 if (SYMBOL_CLASS (sym
) == LOC_STATIC
18435 && SYMBOL_VALUE_ADDRESS (sym
) == 0
18436 && !dwarf2_per_objfile
->has_section_at_zero
)
18438 /* When a static variable is eliminated by the linker,
18439 the corresponding debug information is not stripped
18440 out, but the variable address is set to null;
18441 do not add such variables into symbol table. */
18443 else if (attr2
&& (DW_UNSND (attr2
) != 0))
18445 /* Workaround gfortran PR debug/40040 - it uses
18446 DW_AT_location for variables in -fPIC libraries which may
18447 get overriden by other libraries/executable and get
18448 a different address. Resolve it by the minimal symbol
18449 which may come from inferior's executable using copy
18450 relocation. Make this workaround only for gfortran as for
18451 other compilers GDB cannot guess the minimal symbol
18452 Fortran mangling kind. */
18453 if (cu
->language
== language_fortran
&& die
->parent
18454 && die
->parent
->tag
== DW_TAG_module
18456 && startswith (cu
->producer
, "GNU Fortran "))
18457 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18459 /* A variable with DW_AT_external is never static,
18460 but it may be block-scoped. */
18461 list_to_add
= (cu
->list_in_scope
== &file_symbols
18462 ? &global_symbols
: cu
->list_in_scope
);
18465 list_to_add
= cu
->list_in_scope
;
18469 /* We do not know the address of this symbol.
18470 If it is an external symbol and we have type information
18471 for it, enter the symbol as a LOC_UNRESOLVED symbol.
18472 The address of the variable will then be determined from
18473 the minimal symbol table whenever the variable is
18475 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
18477 /* Fortran explicitly imports any global symbols to the local
18478 scope by DW_TAG_common_block. */
18479 if (cu
->language
== language_fortran
&& die
->parent
18480 && die
->parent
->tag
== DW_TAG_common_block
)
18482 /* SYMBOL_CLASS doesn't matter here because
18483 read_common_block is going to reset it. */
18485 list_to_add
= cu
->list_in_scope
;
18487 else if (attr2
&& (DW_UNSND (attr2
) != 0)
18488 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
18490 /* A variable with DW_AT_external is never static, but it
18491 may be block-scoped. */
18492 list_to_add
= (cu
->list_in_scope
== &file_symbols
18493 ? &global_symbols
: cu
->list_in_scope
);
18495 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
18497 else if (!die_is_declaration (die
, cu
))
18499 /* Use the default LOC_OPTIMIZED_OUT class. */
18500 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
18502 list_to_add
= cu
->list_in_scope
;
18506 case DW_TAG_formal_parameter
:
18507 /* If we are inside a function, mark this as an argument. If
18508 not, we might be looking at an argument to an inlined function
18509 when we do not have enough information to show inlined frames;
18510 pretend it's a local variable in that case so that the user can
18512 if (context_stack_depth
> 0
18513 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
18514 SYMBOL_IS_ARGUMENT (sym
) = 1;
18515 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
18518 var_decode_location (attr
, sym
, cu
);
18520 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18523 dwarf2_const_value (attr
, sym
, cu
);
18526 list_to_add
= cu
->list_in_scope
;
18528 case DW_TAG_unspecified_parameters
:
18529 /* From varargs functions; gdb doesn't seem to have any
18530 interest in this information, so just ignore it for now.
18533 case DW_TAG_template_type_param
:
18535 /* Fall through. */
18536 case DW_TAG_class_type
:
18537 case DW_TAG_interface_type
:
18538 case DW_TAG_structure_type
:
18539 case DW_TAG_union_type
:
18540 case DW_TAG_set_type
:
18541 case DW_TAG_enumeration_type
:
18542 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18543 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
18546 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
18547 really ever be static objects: otherwise, if you try
18548 to, say, break of a class's method and you're in a file
18549 which doesn't mention that class, it won't work unless
18550 the check for all static symbols in lookup_symbol_aux
18551 saves you. See the OtherFileClass tests in
18552 gdb.c++/namespace.exp. */
18556 list_to_add
= (cu
->list_in_scope
== &file_symbols
18557 && (cu
->language
== language_cplus
18558 || cu
->language
== language_java
)
18559 ? &global_symbols
: cu
->list_in_scope
);
18561 /* The semantics of C++ state that "struct foo {
18562 ... }" also defines a typedef for "foo". A Java
18563 class declaration also defines a typedef for the
18565 if (cu
->language
== language_cplus
18566 || cu
->language
== language_java
18567 || cu
->language
== language_ada
18568 || cu
->language
== language_d
)
18570 /* The symbol's name is already allocated along
18571 with this objfile, so we don't need to
18572 duplicate it for the type. */
18573 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
18574 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
18579 case DW_TAG_typedef
:
18580 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18581 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18582 list_to_add
= cu
->list_in_scope
;
18584 case DW_TAG_base_type
:
18585 case DW_TAG_subrange_type
:
18586 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18587 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
18588 list_to_add
= cu
->list_in_scope
;
18590 case DW_TAG_enumerator
:
18591 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
18594 dwarf2_const_value (attr
, sym
, cu
);
18597 /* NOTE: carlton/2003-11-10: See comment above in the
18598 DW_TAG_class_type, etc. block. */
18600 list_to_add
= (cu
->list_in_scope
== &file_symbols
18601 && (cu
->language
== language_cplus
18602 || cu
->language
== language_java
)
18603 ? &global_symbols
: cu
->list_in_scope
);
18606 case DW_TAG_imported_declaration
:
18607 case DW_TAG_namespace
:
18608 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18609 list_to_add
= &global_symbols
;
18611 case DW_TAG_module
:
18612 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
18613 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
18614 list_to_add
= &global_symbols
;
18616 case DW_TAG_common_block
:
18617 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
18618 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
18619 add_symbol_to_list (sym
, cu
->list_in_scope
);
18622 /* Not a tag we recognize. Hopefully we aren't processing
18623 trash data, but since we must specifically ignore things
18624 we don't recognize, there is nothing else we should do at
18626 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
18627 dwarf_tag_name (die
->tag
));
18633 sym
->hash_next
= objfile
->template_symbols
;
18634 objfile
->template_symbols
= sym
;
18635 list_to_add
= NULL
;
18638 if (list_to_add
!= NULL
)
18639 add_symbol_to_list (sym
, list_to_add
);
18641 /* For the benefit of old versions of GCC, check for anonymous
18642 namespaces based on the demangled name. */
18643 if (!cu
->processing_has_namespace_info
18644 && cu
->language
== language_cplus
)
18645 cp_scan_for_anonymous_namespaces (sym
, objfile
);
18650 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18652 static struct symbol
*
18653 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
18655 return new_symbol_full (die
, type
, cu
, NULL
);
18658 /* Given an attr with a DW_FORM_dataN value in host byte order,
18659 zero-extend it as appropriate for the symbol's type. The DWARF
18660 standard (v4) is not entirely clear about the meaning of using
18661 DW_FORM_dataN for a constant with a signed type, where the type is
18662 wider than the data. The conclusion of a discussion on the DWARF
18663 list was that this is unspecified. We choose to always zero-extend
18664 because that is the interpretation long in use by GCC. */
18667 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
18668 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
18670 struct objfile
*objfile
= cu
->objfile
;
18671 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
18672 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
18673 LONGEST l
= DW_UNSND (attr
);
18675 if (bits
< sizeof (*value
) * 8)
18677 l
&= ((LONGEST
) 1 << bits
) - 1;
18680 else if (bits
== sizeof (*value
) * 8)
18684 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
18685 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
18692 /* Read a constant value from an attribute. Either set *VALUE, or if
18693 the value does not fit in *VALUE, set *BYTES - either already
18694 allocated on the objfile obstack, or newly allocated on OBSTACK,
18695 or, set *BATON, if we translated the constant to a location
18699 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
18700 const char *name
, struct obstack
*obstack
,
18701 struct dwarf2_cu
*cu
,
18702 LONGEST
*value
, const gdb_byte
**bytes
,
18703 struct dwarf2_locexpr_baton
**baton
)
18705 struct objfile
*objfile
= cu
->objfile
;
18706 struct comp_unit_head
*cu_header
= &cu
->header
;
18707 struct dwarf_block
*blk
;
18708 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
18709 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
18715 switch (attr
->form
)
18718 case DW_FORM_GNU_addr_index
:
18722 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
18723 dwarf2_const_value_length_mismatch_complaint (name
,
18724 cu_header
->addr_size
,
18725 TYPE_LENGTH (type
));
18726 /* Symbols of this form are reasonably rare, so we just
18727 piggyback on the existing location code rather than writing
18728 a new implementation of symbol_computed_ops. */
18729 *baton
= obstack_alloc (obstack
, sizeof (struct dwarf2_locexpr_baton
));
18730 (*baton
)->per_cu
= cu
->per_cu
;
18731 gdb_assert ((*baton
)->per_cu
);
18733 (*baton
)->size
= 2 + cu_header
->addr_size
;
18734 data
= obstack_alloc (obstack
, (*baton
)->size
);
18735 (*baton
)->data
= data
;
18737 data
[0] = DW_OP_addr
;
18738 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
18739 byte_order
, DW_ADDR (attr
));
18740 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
18743 case DW_FORM_string
:
18745 case DW_FORM_GNU_str_index
:
18746 case DW_FORM_GNU_strp_alt
:
18747 /* DW_STRING is already allocated on the objfile obstack, point
18749 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
18751 case DW_FORM_block1
:
18752 case DW_FORM_block2
:
18753 case DW_FORM_block4
:
18754 case DW_FORM_block
:
18755 case DW_FORM_exprloc
:
18756 blk
= DW_BLOCK (attr
);
18757 if (TYPE_LENGTH (type
) != blk
->size
)
18758 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
18759 TYPE_LENGTH (type
));
18760 *bytes
= blk
->data
;
18763 /* The DW_AT_const_value attributes are supposed to carry the
18764 symbol's value "represented as it would be on the target
18765 architecture." By the time we get here, it's already been
18766 converted to host endianness, so we just need to sign- or
18767 zero-extend it as appropriate. */
18768 case DW_FORM_data1
:
18769 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
18771 case DW_FORM_data2
:
18772 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
18774 case DW_FORM_data4
:
18775 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
18777 case DW_FORM_data8
:
18778 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
18781 case DW_FORM_sdata
:
18782 *value
= DW_SND (attr
);
18785 case DW_FORM_udata
:
18786 *value
= DW_UNSND (attr
);
18790 complaint (&symfile_complaints
,
18791 _("unsupported const value attribute form: '%s'"),
18792 dwarf_form_name (attr
->form
));
18799 /* Copy constant value from an attribute to a symbol. */
18802 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
18803 struct dwarf2_cu
*cu
)
18805 struct objfile
*objfile
= cu
->objfile
;
18806 struct comp_unit_head
*cu_header
= &cu
->header
;
18808 const gdb_byte
*bytes
;
18809 struct dwarf2_locexpr_baton
*baton
;
18811 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
18812 SYMBOL_PRINT_NAME (sym
),
18813 &objfile
->objfile_obstack
, cu
,
18814 &value
, &bytes
, &baton
);
18818 SYMBOL_LOCATION_BATON (sym
) = baton
;
18819 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
18821 else if (bytes
!= NULL
)
18823 SYMBOL_VALUE_BYTES (sym
) = bytes
;
18824 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
18828 SYMBOL_VALUE (sym
) = value
;
18829 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
18833 /* Return the type of the die in question using its DW_AT_type attribute. */
18835 static struct type
*
18836 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18838 struct attribute
*type_attr
;
18840 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
18843 /* A missing DW_AT_type represents a void type. */
18844 return objfile_type (cu
->objfile
)->builtin_void
;
18847 return lookup_die_type (die
, type_attr
, cu
);
18850 /* True iff CU's producer generates GNAT Ada auxiliary information
18851 that allows to find parallel types through that information instead
18852 of having to do expensive parallel lookups by type name. */
18855 need_gnat_info (struct dwarf2_cu
*cu
)
18857 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18858 of GNAT produces this auxiliary information, without any indication
18859 that it is produced. Part of enhancing the FSF version of GNAT
18860 to produce that information will be to put in place an indicator
18861 that we can use in order to determine whether the descriptive type
18862 info is available or not. One suggestion that has been made is
18863 to use a new attribute, attached to the CU die. For now, assume
18864 that the descriptive type info is not available. */
18868 /* Return the auxiliary type of the die in question using its
18869 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18870 attribute is not present. */
18872 static struct type
*
18873 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18875 struct attribute
*type_attr
;
18877 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
18881 return lookup_die_type (die
, type_attr
, cu
);
18884 /* If DIE has a descriptive_type attribute, then set the TYPE's
18885 descriptive type accordingly. */
18888 set_descriptive_type (struct type
*type
, struct die_info
*die
,
18889 struct dwarf2_cu
*cu
)
18891 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
18893 if (descriptive_type
)
18895 ALLOCATE_GNAT_AUX_TYPE (type
);
18896 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
18900 /* Return the containing type of the die in question using its
18901 DW_AT_containing_type attribute. */
18903 static struct type
*
18904 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18906 struct attribute
*type_attr
;
18908 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
18910 error (_("Dwarf Error: Problem turning containing type into gdb type "
18911 "[in module %s]"), objfile_name (cu
->objfile
));
18913 return lookup_die_type (die
, type_attr
, cu
);
18916 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18918 static struct type
*
18919 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
18921 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18922 char *message
, *saved
;
18924 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18925 objfile_name (objfile
),
18926 cu
->header
.offset
.sect_off
,
18927 die
->offset
.sect_off
);
18928 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
18929 message
, strlen (message
));
18932 return init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
18935 /* Look up the type of DIE in CU using its type attribute ATTR.
18936 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18937 DW_AT_containing_type.
18938 If there is no type substitute an error marker. */
18940 static struct type
*
18941 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
18942 struct dwarf2_cu
*cu
)
18944 struct objfile
*objfile
= cu
->objfile
;
18945 struct type
*this_type
;
18947 gdb_assert (attr
->name
== DW_AT_type
18948 || attr
->name
== DW_AT_GNAT_descriptive_type
18949 || attr
->name
== DW_AT_containing_type
);
18951 /* First see if we have it cached. */
18953 if (attr
->form
== DW_FORM_GNU_ref_alt
)
18955 struct dwarf2_per_cu_data
*per_cu
;
18956 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18958 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
18959 this_type
= get_die_type_at_offset (offset
, per_cu
);
18961 else if (attr_form_is_ref (attr
))
18963 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
18965 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
18967 else if (attr
->form
== DW_FORM_ref_sig8
)
18969 ULONGEST signature
= DW_SIGNATURE (attr
);
18971 return get_signatured_type (die
, signature
, cu
);
18975 complaint (&symfile_complaints
,
18976 _("Dwarf Error: Bad type attribute %s in DIE"
18977 " at 0x%x [in module %s]"),
18978 dwarf_attr_name (attr
->name
), die
->offset
.sect_off
,
18979 objfile_name (objfile
));
18980 return build_error_marker_type (cu
, die
);
18983 /* If not cached we need to read it in. */
18985 if (this_type
== NULL
)
18987 struct die_info
*type_die
= NULL
;
18988 struct dwarf2_cu
*type_cu
= cu
;
18990 if (attr_form_is_ref (attr
))
18991 type_die
= follow_die_ref (die
, attr
, &type_cu
);
18992 if (type_die
== NULL
)
18993 return build_error_marker_type (cu
, die
);
18994 /* If we find the type now, it's probably because the type came
18995 from an inter-CU reference and the type's CU got expanded before
18997 this_type
= read_type_die (type_die
, type_cu
);
19000 /* If we still don't have a type use an error marker. */
19002 if (this_type
== NULL
)
19003 return build_error_marker_type (cu
, die
);
19008 /* Return the type in DIE, CU.
19009 Returns NULL for invalid types.
19011 This first does a lookup in die_type_hash,
19012 and only reads the die in if necessary.
19014 NOTE: This can be called when reading in partial or full symbols. */
19016 static struct type
*
19017 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
19019 struct type
*this_type
;
19021 this_type
= get_die_type (die
, cu
);
19025 return read_type_die_1 (die
, cu
);
19028 /* Read the type in DIE, CU.
19029 Returns NULL for invalid types. */
19031 static struct type
*
19032 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
19034 struct type
*this_type
= NULL
;
19038 case DW_TAG_class_type
:
19039 case DW_TAG_interface_type
:
19040 case DW_TAG_structure_type
:
19041 case DW_TAG_union_type
:
19042 this_type
= read_structure_type (die
, cu
);
19044 case DW_TAG_enumeration_type
:
19045 this_type
= read_enumeration_type (die
, cu
);
19047 case DW_TAG_subprogram
:
19048 case DW_TAG_subroutine_type
:
19049 case DW_TAG_inlined_subroutine
:
19050 this_type
= read_subroutine_type (die
, cu
);
19052 case DW_TAG_array_type
:
19053 this_type
= read_array_type (die
, cu
);
19055 case DW_TAG_set_type
:
19056 this_type
= read_set_type (die
, cu
);
19058 case DW_TAG_pointer_type
:
19059 this_type
= read_tag_pointer_type (die
, cu
);
19061 case DW_TAG_ptr_to_member_type
:
19062 this_type
= read_tag_ptr_to_member_type (die
, cu
);
19064 case DW_TAG_reference_type
:
19065 this_type
= read_tag_reference_type (die
, cu
);
19067 case DW_TAG_const_type
:
19068 this_type
= read_tag_const_type (die
, cu
);
19070 case DW_TAG_volatile_type
:
19071 this_type
= read_tag_volatile_type (die
, cu
);
19073 case DW_TAG_restrict_type
:
19074 this_type
= read_tag_restrict_type (die
, cu
);
19076 case DW_TAG_string_type
:
19077 this_type
= read_tag_string_type (die
, cu
);
19079 case DW_TAG_typedef
:
19080 this_type
= read_typedef (die
, cu
);
19082 case DW_TAG_subrange_type
:
19083 this_type
= read_subrange_type (die
, cu
);
19085 case DW_TAG_base_type
:
19086 this_type
= read_base_type (die
, cu
);
19088 case DW_TAG_unspecified_type
:
19089 this_type
= read_unspecified_type (die
, cu
);
19091 case DW_TAG_namespace
:
19092 this_type
= read_namespace_type (die
, cu
);
19094 case DW_TAG_module
:
19095 this_type
= read_module_type (die
, cu
);
19097 case DW_TAG_atomic_type
:
19098 this_type
= read_tag_atomic_type (die
, cu
);
19101 complaint (&symfile_complaints
,
19102 _("unexpected tag in read_type_die: '%s'"),
19103 dwarf_tag_name (die
->tag
));
19110 /* See if we can figure out if the class lives in a namespace. We do
19111 this by looking for a member function; its demangled name will
19112 contain namespace info, if there is any.
19113 Return the computed name or NULL.
19114 Space for the result is allocated on the objfile's obstack.
19115 This is the full-die version of guess_partial_die_structure_name.
19116 In this case we know DIE has no useful parent. */
19119 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19121 struct die_info
*spec_die
;
19122 struct dwarf2_cu
*spec_cu
;
19123 struct die_info
*child
;
19126 spec_die
= die_specification (die
, &spec_cu
);
19127 if (spec_die
!= NULL
)
19133 for (child
= die
->child
;
19135 child
= child
->sibling
)
19137 if (child
->tag
== DW_TAG_subprogram
)
19139 struct attribute
*attr
;
19141 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
19143 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
19147 = language_class_name_from_physname (cu
->language_defn
,
19151 if (actual_name
!= NULL
)
19153 const char *die_name
= dwarf2_name (die
, cu
);
19155 if (die_name
!= NULL
19156 && strcmp (die_name
, actual_name
) != 0)
19158 /* Strip off the class name from the full name.
19159 We want the prefix. */
19160 int die_name_len
= strlen (die_name
);
19161 int actual_name_len
= strlen (actual_name
);
19163 /* Test for '::' as a sanity check. */
19164 if (actual_name_len
> die_name_len
+ 2
19165 && actual_name
[actual_name_len
19166 - die_name_len
- 1] == ':')
19168 obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19170 actual_name_len
- die_name_len
- 2);
19173 xfree (actual_name
);
19182 /* GCC might emit a nameless typedef that has a linkage name. Determine the
19183 prefix part in such case. See
19184 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19187 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19189 struct attribute
*attr
;
19192 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
19193 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
19196 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19197 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19200 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19202 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19203 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19206 /* dwarf2_name had to be already called. */
19207 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
19209 /* Strip the base name, keep any leading namespaces/classes. */
19210 base
= strrchr (DW_STRING (attr
), ':');
19211 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
19214 return obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19215 DW_STRING (attr
), &base
[-1] - DW_STRING (attr
));
19218 /* Return the name of the namespace/class that DIE is defined within,
19219 or "" if we can't tell. The caller should not xfree the result.
19221 For example, if we're within the method foo() in the following
19231 then determine_prefix on foo's die will return "N::C". */
19233 static const char *
19234 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
19236 struct die_info
*parent
, *spec_die
;
19237 struct dwarf2_cu
*spec_cu
;
19238 struct type
*parent_type
;
19241 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
19242 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
)
19245 retval
= anonymous_struct_prefix (die
, cu
);
19249 /* We have to be careful in the presence of DW_AT_specification.
19250 For example, with GCC 3.4, given the code
19254 // Definition of N::foo.
19258 then we'll have a tree of DIEs like this:
19260 1: DW_TAG_compile_unit
19261 2: DW_TAG_namespace // N
19262 3: DW_TAG_subprogram // declaration of N::foo
19263 4: DW_TAG_subprogram // definition of N::foo
19264 DW_AT_specification // refers to die #3
19266 Thus, when processing die #4, we have to pretend that we're in
19267 the context of its DW_AT_specification, namely the contex of die
19270 spec_die
= die_specification (die
, &spec_cu
);
19271 if (spec_die
== NULL
)
19272 parent
= die
->parent
;
19275 parent
= spec_die
->parent
;
19279 if (parent
== NULL
)
19281 else if (parent
->building_fullname
)
19284 const char *parent_name
;
19286 /* It has been seen on RealView 2.2 built binaries,
19287 DW_TAG_template_type_param types actually _defined_ as
19288 children of the parent class:
19291 template class <class Enum> Class{};
19292 Class<enum E> class_e;
19294 1: DW_TAG_class_type (Class)
19295 2: DW_TAG_enumeration_type (E)
19296 3: DW_TAG_enumerator (enum1:0)
19297 3: DW_TAG_enumerator (enum2:1)
19299 2: DW_TAG_template_type_param
19300 DW_AT_type DW_FORM_ref_udata (E)
19302 Besides being broken debug info, it can put GDB into an
19303 infinite loop. Consider:
19305 When we're building the full name for Class<E>, we'll start
19306 at Class, and go look over its template type parameters,
19307 finding E. We'll then try to build the full name of E, and
19308 reach here. We're now trying to build the full name of E,
19309 and look over the parent DIE for containing scope. In the
19310 broken case, if we followed the parent DIE of E, we'd again
19311 find Class, and once again go look at its template type
19312 arguments, etc., etc. Simply don't consider such parent die
19313 as source-level parent of this die (it can't be, the language
19314 doesn't allow it), and break the loop here. */
19315 name
= dwarf2_name (die
, cu
);
19316 parent_name
= dwarf2_name (parent
, cu
);
19317 complaint (&symfile_complaints
,
19318 _("template param type '%s' defined within parent '%s'"),
19319 name
? name
: "<unknown>",
19320 parent_name
? parent_name
: "<unknown>");
19324 switch (parent
->tag
)
19326 case DW_TAG_namespace
:
19327 parent_type
= read_type_die (parent
, cu
);
19328 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
19329 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
19330 Work around this problem here. */
19331 if (cu
->language
== language_cplus
19332 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
19334 /* We give a name to even anonymous namespaces. */
19335 return TYPE_TAG_NAME (parent_type
);
19336 case DW_TAG_class_type
:
19337 case DW_TAG_interface_type
:
19338 case DW_TAG_structure_type
:
19339 case DW_TAG_union_type
:
19340 case DW_TAG_module
:
19341 parent_type
= read_type_die (parent
, cu
);
19342 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19343 return TYPE_TAG_NAME (parent_type
);
19345 /* An anonymous structure is only allowed non-static data
19346 members; no typedefs, no member functions, et cetera.
19347 So it does not need a prefix. */
19349 case DW_TAG_compile_unit
:
19350 case DW_TAG_partial_unit
:
19351 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
19352 if (cu
->language
== language_cplus
19353 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
19354 && die
->child
!= NULL
19355 && (die
->tag
== DW_TAG_class_type
19356 || die
->tag
== DW_TAG_structure_type
19357 || die
->tag
== DW_TAG_union_type
))
19359 char *name
= guess_full_die_structure_name (die
, cu
);
19364 case DW_TAG_enumeration_type
:
19365 parent_type
= read_type_die (parent
, cu
);
19366 if (TYPE_DECLARED_CLASS (parent_type
))
19368 if (TYPE_TAG_NAME (parent_type
) != NULL
)
19369 return TYPE_TAG_NAME (parent_type
);
19372 /* Fall through. */
19374 return determine_prefix (parent
, cu
);
19378 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
19379 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
19380 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
19381 an obconcat, otherwise allocate storage for the result. The CU argument is
19382 used to determine the language and hence, the appropriate separator. */
19384 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
19387 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
19388 int physname
, struct dwarf2_cu
*cu
)
19390 const char *lead
= "";
19393 if (suffix
== NULL
|| suffix
[0] == '\0'
19394 || prefix
== NULL
|| prefix
[0] == '\0')
19396 else if (cu
->language
== language_java
)
19398 else if (cu
->language
== language_d
)
19400 /* For D, the 'main' function could be defined in any module, but it
19401 should never be prefixed. */
19402 if (strcmp (suffix
, "D main") == 0)
19410 else if (cu
->language
== language_fortran
&& physname
)
19412 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
19413 DW_AT_MIPS_linkage_name is preferred and used instead. */
19421 if (prefix
== NULL
)
19423 if (suffix
== NULL
)
19429 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
19431 strcpy (retval
, lead
);
19432 strcat (retval
, prefix
);
19433 strcat (retval
, sep
);
19434 strcat (retval
, suffix
);
19439 /* We have an obstack. */
19440 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
19444 /* Return sibling of die, NULL if no sibling. */
19446 static struct die_info
*
19447 sibling_die (struct die_info
*die
)
19449 return die
->sibling
;
19452 /* Get name of a die, return NULL if not found. */
19454 static const char *
19455 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
19456 struct obstack
*obstack
)
19458 if (name
&& cu
->language
== language_cplus
)
19460 char *canon_name
= cp_canonicalize_string (name
);
19462 if (canon_name
!= NULL
)
19464 if (strcmp (canon_name
, name
) != 0)
19465 name
= obstack_copy0 (obstack
, canon_name
, strlen (canon_name
));
19466 xfree (canon_name
);
19473 /* Get name of a die, return NULL if not found.
19474 Anonymous namespaces are converted to their magic string. */
19476 static const char *
19477 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19479 struct attribute
*attr
;
19481 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
19482 if ((!attr
|| !DW_STRING (attr
))
19483 && die
->tag
!= DW_TAG_namespace
19484 && die
->tag
!= DW_TAG_class_type
19485 && die
->tag
!= DW_TAG_interface_type
19486 && die
->tag
!= DW_TAG_structure_type
19487 && die
->tag
!= DW_TAG_union_type
)
19492 case DW_TAG_compile_unit
:
19493 case DW_TAG_partial_unit
:
19494 /* Compilation units have a DW_AT_name that is a filename, not
19495 a source language identifier. */
19496 case DW_TAG_enumeration_type
:
19497 case DW_TAG_enumerator
:
19498 /* These tags always have simple identifiers already; no need
19499 to canonicalize them. */
19500 return DW_STRING (attr
);
19502 case DW_TAG_namespace
:
19503 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
19504 return DW_STRING (attr
);
19505 return CP_ANONYMOUS_NAMESPACE_STR
;
19507 case DW_TAG_subprogram
:
19508 /* Java constructors will all be named "<init>", so return
19509 the class name when we see this special case. */
19510 if (cu
->language
== language_java
19511 && DW_STRING (attr
) != NULL
19512 && strcmp (DW_STRING (attr
), "<init>") == 0)
19514 struct dwarf2_cu
*spec_cu
= cu
;
19515 struct die_info
*spec_die
;
19517 /* GCJ will output '<init>' for Java constructor names.
19518 For this special case, return the name of the parent class. */
19520 /* GCJ may output subprogram DIEs with AT_specification set.
19521 If so, use the name of the specified DIE. */
19522 spec_die
= die_specification (die
, &spec_cu
);
19523 if (spec_die
!= NULL
)
19524 return dwarf2_name (spec_die
, spec_cu
);
19529 if (die
->tag
== DW_TAG_class_type
)
19530 return dwarf2_name (die
, cu
);
19532 while (die
->tag
!= DW_TAG_compile_unit
19533 && die
->tag
!= DW_TAG_partial_unit
);
19537 case DW_TAG_class_type
:
19538 case DW_TAG_interface_type
:
19539 case DW_TAG_structure_type
:
19540 case DW_TAG_union_type
:
19541 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19542 structures or unions. These were of the form "._%d" in GCC 4.1,
19543 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19544 and GCC 4.4. We work around this problem by ignoring these. */
19545 if (attr
&& DW_STRING (attr
)
19546 && (startswith (DW_STRING (attr
), "._")
19547 || startswith (DW_STRING (attr
), "<anonymous")))
19550 /* GCC might emit a nameless typedef that has a linkage name. See
19551 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19552 if (!attr
|| DW_STRING (attr
) == NULL
)
19554 char *demangled
= NULL
;
19556 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
19558 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
19560 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
19563 /* Avoid demangling DW_STRING (attr) the second time on a second
19564 call for the same DIE. */
19565 if (!DW_STRING_IS_CANONICAL (attr
))
19566 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
19572 /* FIXME: we already did this for the partial symbol... */
19574 = obstack_copy0 (&cu
->objfile
->per_bfd
->storage_obstack
,
19575 demangled
, strlen (demangled
));
19576 DW_STRING_IS_CANONICAL (attr
) = 1;
19579 /* Strip any leading namespaces/classes, keep only the base name.
19580 DW_AT_name for named DIEs does not contain the prefixes. */
19581 base
= strrchr (DW_STRING (attr
), ':');
19582 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
19585 return DW_STRING (attr
);
19594 if (!DW_STRING_IS_CANONICAL (attr
))
19597 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
19598 &cu
->objfile
->per_bfd
->storage_obstack
);
19599 DW_STRING_IS_CANONICAL (attr
) = 1;
19601 return DW_STRING (attr
);
19604 /* Return the die that this die in an extension of, or NULL if there
19605 is none. *EXT_CU is the CU containing DIE on input, and the CU
19606 containing the return value on output. */
19608 static struct die_info
*
19609 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
19611 struct attribute
*attr
;
19613 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
19617 return follow_die_ref (die
, attr
, ext_cu
);
19620 /* Convert a DIE tag into its string name. */
19622 static const char *
19623 dwarf_tag_name (unsigned tag
)
19625 const char *name
= get_DW_TAG_name (tag
);
19628 return "DW_TAG_<unknown>";
19633 /* Convert a DWARF attribute code into its string name. */
19635 static const char *
19636 dwarf_attr_name (unsigned attr
)
19640 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19641 if (attr
== DW_AT_MIPS_fde
)
19642 return "DW_AT_MIPS_fde";
19644 if (attr
== DW_AT_HP_block_index
)
19645 return "DW_AT_HP_block_index";
19648 name
= get_DW_AT_name (attr
);
19651 return "DW_AT_<unknown>";
19656 /* Convert a DWARF value form code into its string name. */
19658 static const char *
19659 dwarf_form_name (unsigned form
)
19661 const char *name
= get_DW_FORM_name (form
);
19664 return "DW_FORM_<unknown>";
19670 dwarf_bool_name (unsigned mybool
)
19678 /* Convert a DWARF type code into its string name. */
19680 static const char *
19681 dwarf_type_encoding_name (unsigned enc
)
19683 const char *name
= get_DW_ATE_name (enc
);
19686 return "DW_ATE_<unknown>";
19692 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
19696 print_spaces (indent
, f
);
19697 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
19698 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
19700 if (die
->parent
!= NULL
)
19702 print_spaces (indent
, f
);
19703 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
19704 die
->parent
->offset
.sect_off
);
19707 print_spaces (indent
, f
);
19708 fprintf_unfiltered (f
, " has children: %s\n",
19709 dwarf_bool_name (die
->child
!= NULL
));
19711 print_spaces (indent
, f
);
19712 fprintf_unfiltered (f
, " attributes:\n");
19714 for (i
= 0; i
< die
->num_attrs
; ++i
)
19716 print_spaces (indent
, f
);
19717 fprintf_unfiltered (f
, " %s (%s) ",
19718 dwarf_attr_name (die
->attrs
[i
].name
),
19719 dwarf_form_name (die
->attrs
[i
].form
));
19721 switch (die
->attrs
[i
].form
)
19724 case DW_FORM_GNU_addr_index
:
19725 fprintf_unfiltered (f
, "address: ");
19726 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
19728 case DW_FORM_block2
:
19729 case DW_FORM_block4
:
19730 case DW_FORM_block
:
19731 case DW_FORM_block1
:
19732 fprintf_unfiltered (f
, "block: size %s",
19733 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19735 case DW_FORM_exprloc
:
19736 fprintf_unfiltered (f
, "expression: size %s",
19737 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
19739 case DW_FORM_ref_addr
:
19740 fprintf_unfiltered (f
, "ref address: ");
19741 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19743 case DW_FORM_GNU_ref_alt
:
19744 fprintf_unfiltered (f
, "alt ref address: ");
19745 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
19751 case DW_FORM_ref_udata
:
19752 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
19753 (long) (DW_UNSND (&die
->attrs
[i
])));
19755 case DW_FORM_data1
:
19756 case DW_FORM_data2
:
19757 case DW_FORM_data4
:
19758 case DW_FORM_data8
:
19759 case DW_FORM_udata
:
19760 case DW_FORM_sdata
:
19761 fprintf_unfiltered (f
, "constant: %s",
19762 pulongest (DW_UNSND (&die
->attrs
[i
])));
19764 case DW_FORM_sec_offset
:
19765 fprintf_unfiltered (f
, "section offset: %s",
19766 pulongest (DW_UNSND (&die
->attrs
[i
])));
19768 case DW_FORM_ref_sig8
:
19769 fprintf_unfiltered (f
, "signature: %s",
19770 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
19772 case DW_FORM_string
:
19774 case DW_FORM_GNU_str_index
:
19775 case DW_FORM_GNU_strp_alt
:
19776 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
19777 DW_STRING (&die
->attrs
[i
])
19778 ? DW_STRING (&die
->attrs
[i
]) : "",
19779 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
19782 if (DW_UNSND (&die
->attrs
[i
]))
19783 fprintf_unfiltered (f
, "flag: TRUE");
19785 fprintf_unfiltered (f
, "flag: FALSE");
19787 case DW_FORM_flag_present
:
19788 fprintf_unfiltered (f
, "flag: TRUE");
19790 case DW_FORM_indirect
:
19791 /* The reader will have reduced the indirect form to
19792 the "base form" so this form should not occur. */
19793 fprintf_unfiltered (f
,
19794 "unexpected attribute form: DW_FORM_indirect");
19797 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
19798 die
->attrs
[i
].form
);
19801 fprintf_unfiltered (f
, "\n");
19806 dump_die_for_error (struct die_info
*die
)
19808 dump_die_shallow (gdb_stderr
, 0, die
);
19812 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
19814 int indent
= level
* 4;
19816 gdb_assert (die
!= NULL
);
19818 if (level
>= max_level
)
19821 dump_die_shallow (f
, indent
, die
);
19823 if (die
->child
!= NULL
)
19825 print_spaces (indent
, f
);
19826 fprintf_unfiltered (f
, " Children:");
19827 if (level
+ 1 < max_level
)
19829 fprintf_unfiltered (f
, "\n");
19830 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
19834 fprintf_unfiltered (f
,
19835 " [not printed, max nesting level reached]\n");
19839 if (die
->sibling
!= NULL
&& level
> 0)
19841 dump_die_1 (f
, level
, max_level
, die
->sibling
);
19845 /* This is called from the pdie macro in gdbinit.in.
19846 It's not static so gcc will keep a copy callable from gdb. */
19849 dump_die (struct die_info
*die
, int max_level
)
19851 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
19855 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
19859 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
19865 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19869 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
19871 sect_offset retval
= { DW_UNSND (attr
) };
19873 if (attr_form_is_ref (attr
))
19876 retval
.sect_off
= 0;
19877 complaint (&symfile_complaints
,
19878 _("unsupported die ref attribute form: '%s'"),
19879 dwarf_form_name (attr
->form
));
19883 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19884 * the value held by the attribute is not constant. */
19887 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
19889 if (attr
->form
== DW_FORM_sdata
)
19890 return DW_SND (attr
);
19891 else if (attr
->form
== DW_FORM_udata
19892 || attr
->form
== DW_FORM_data1
19893 || attr
->form
== DW_FORM_data2
19894 || attr
->form
== DW_FORM_data4
19895 || attr
->form
== DW_FORM_data8
)
19896 return DW_UNSND (attr
);
19899 complaint (&symfile_complaints
,
19900 _("Attribute value is not a constant (%s)"),
19901 dwarf_form_name (attr
->form
));
19902 return default_value
;
19906 /* Follow reference or signature attribute ATTR of SRC_DIE.
19907 On entry *REF_CU is the CU of SRC_DIE.
19908 On exit *REF_CU is the CU of the result. */
19910 static struct die_info
*
19911 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
19912 struct dwarf2_cu
**ref_cu
)
19914 struct die_info
*die
;
19916 if (attr_form_is_ref (attr
))
19917 die
= follow_die_ref (src_die
, attr
, ref_cu
);
19918 else if (attr
->form
== DW_FORM_ref_sig8
)
19919 die
= follow_die_sig (src_die
, attr
, ref_cu
);
19922 dump_die_for_error (src_die
);
19923 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19924 objfile_name ((*ref_cu
)->objfile
));
19930 /* Follow reference OFFSET.
19931 On entry *REF_CU is the CU of the source die referencing OFFSET.
19932 On exit *REF_CU is the CU of the result.
19933 Returns NULL if OFFSET is invalid. */
19935 static struct die_info
*
19936 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
19937 struct dwarf2_cu
**ref_cu
)
19939 struct die_info temp_die
;
19940 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
19942 gdb_assert (cu
->per_cu
!= NULL
);
19946 if (cu
->per_cu
->is_debug_types
)
19948 /* .debug_types CUs cannot reference anything outside their CU.
19949 If they need to, they have to reference a signatured type via
19950 DW_FORM_ref_sig8. */
19951 if (! offset_in_cu_p (&cu
->header
, offset
))
19954 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
19955 || ! offset_in_cu_p (&cu
->header
, offset
))
19957 struct dwarf2_per_cu_data
*per_cu
;
19959 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
19962 /* If necessary, add it to the queue and load its DIEs. */
19963 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
19964 load_full_comp_unit (per_cu
, cu
->language
);
19966 target_cu
= per_cu
->cu
;
19968 else if (cu
->dies
== NULL
)
19970 /* We're loading full DIEs during partial symbol reading. */
19971 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
19972 load_full_comp_unit (cu
->per_cu
, language_minimal
);
19975 *ref_cu
= target_cu
;
19976 temp_die
.offset
= offset
;
19977 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
19980 /* Follow reference attribute ATTR of SRC_DIE.
19981 On entry *REF_CU is the CU of SRC_DIE.
19982 On exit *REF_CU is the CU of the result. */
19984 static struct die_info
*
19985 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
19986 struct dwarf2_cu
**ref_cu
)
19988 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
19989 struct dwarf2_cu
*cu
= *ref_cu
;
19990 struct die_info
*die
;
19992 die
= follow_die_offset (offset
,
19993 (attr
->form
== DW_FORM_GNU_ref_alt
19994 || cu
->per_cu
->is_dwz
),
19997 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19998 "at 0x%x [in module %s]"),
19999 offset
.sect_off
, src_die
->offset
.sect_off
,
20000 objfile_name (cu
->objfile
));
20005 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
20006 Returned value is intended for DW_OP_call*. Returned
20007 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
20009 struct dwarf2_locexpr_baton
20010 dwarf2_fetch_die_loc_sect_off (sect_offset offset
,
20011 struct dwarf2_per_cu_data
*per_cu
,
20012 CORE_ADDR (*get_frame_pc
) (void *baton
),
20015 struct dwarf2_cu
*cu
;
20016 struct die_info
*die
;
20017 struct attribute
*attr
;
20018 struct dwarf2_locexpr_baton retval
;
20020 dw2_setup (per_cu
->objfile
);
20022 if (per_cu
->cu
== NULL
)
20027 /* We shouldn't get here for a dummy CU, but don't crash on the user.
20028 Instead just throw an error, not much else we can do. */
20029 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
20030 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20033 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20035 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20036 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20038 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20041 /* DWARF: "If there is no such attribute, then there is no effect.".
20042 DATA is ignored if SIZE is 0. */
20044 retval
.data
= NULL
;
20047 else if (attr_form_is_section_offset (attr
))
20049 struct dwarf2_loclist_baton loclist_baton
;
20050 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
20053 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
20055 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
20057 retval
.size
= size
;
20061 if (!attr_form_is_block (attr
))
20062 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
20063 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
20064 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20066 retval
.data
= DW_BLOCK (attr
)->data
;
20067 retval
.size
= DW_BLOCK (attr
)->size
;
20069 retval
.per_cu
= cu
->per_cu
;
20071 age_cached_comp_units ();
20076 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
20079 struct dwarf2_locexpr_baton
20080 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
20081 struct dwarf2_per_cu_data
*per_cu
,
20082 CORE_ADDR (*get_frame_pc
) (void *baton
),
20085 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
20087 return dwarf2_fetch_die_loc_sect_off (offset
, per_cu
, get_frame_pc
, baton
);
20090 /* Write a constant of a given type as target-ordered bytes into
20093 static const gdb_byte
*
20094 write_constant_as_bytes (struct obstack
*obstack
,
20095 enum bfd_endian byte_order
,
20102 *len
= TYPE_LENGTH (type
);
20103 result
= obstack_alloc (obstack
, *len
);
20104 store_unsigned_integer (result
, *len
, byte_order
, value
);
20109 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
20110 pointer to the constant bytes and set LEN to the length of the
20111 data. If memory is needed, allocate it on OBSTACK. If the DIE
20112 does not have a DW_AT_const_value, return NULL. */
20115 dwarf2_fetch_constant_bytes (sect_offset offset
,
20116 struct dwarf2_per_cu_data
*per_cu
,
20117 struct obstack
*obstack
,
20120 struct dwarf2_cu
*cu
;
20121 struct die_info
*die
;
20122 struct attribute
*attr
;
20123 const gdb_byte
*result
= NULL
;
20126 enum bfd_endian byte_order
;
20128 dw2_setup (per_cu
->objfile
);
20130 if (per_cu
->cu
== NULL
)
20135 /* We shouldn't get here for a dummy CU, but don't crash on the user.
20136 Instead just throw an error, not much else we can do. */
20137 error (_("Dwarf Error: Dummy CU at 0x%x referenced in module %s"),
20138 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20141 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
20143 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20144 offset
.sect_off
, objfile_name (per_cu
->objfile
));
20147 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20151 byte_order
= (bfd_big_endian (per_cu
->objfile
->obfd
)
20152 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
20154 switch (attr
->form
)
20157 case DW_FORM_GNU_addr_index
:
20161 *len
= cu
->header
.addr_size
;
20162 tem
= obstack_alloc (obstack
, *len
);
20163 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
20167 case DW_FORM_string
:
20169 case DW_FORM_GNU_str_index
:
20170 case DW_FORM_GNU_strp_alt
:
20171 /* DW_STRING is already allocated on the objfile obstack, point
20173 result
= (const gdb_byte
*) DW_STRING (attr
);
20174 *len
= strlen (DW_STRING (attr
));
20176 case DW_FORM_block1
:
20177 case DW_FORM_block2
:
20178 case DW_FORM_block4
:
20179 case DW_FORM_block
:
20180 case DW_FORM_exprloc
:
20181 result
= DW_BLOCK (attr
)->data
;
20182 *len
= DW_BLOCK (attr
)->size
;
20185 /* The DW_AT_const_value attributes are supposed to carry the
20186 symbol's value "represented as it would be on the target
20187 architecture." By the time we get here, it's already been
20188 converted to host endianness, so we just need to sign- or
20189 zero-extend it as appropriate. */
20190 case DW_FORM_data1
:
20191 type
= die_type (die
, cu
);
20192 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
20193 if (result
== NULL
)
20194 result
= write_constant_as_bytes (obstack
, byte_order
,
20197 case DW_FORM_data2
:
20198 type
= die_type (die
, cu
);
20199 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
20200 if (result
== NULL
)
20201 result
= write_constant_as_bytes (obstack
, byte_order
,
20204 case DW_FORM_data4
:
20205 type
= die_type (die
, cu
);
20206 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
20207 if (result
== NULL
)
20208 result
= write_constant_as_bytes (obstack
, byte_order
,
20211 case DW_FORM_data8
:
20212 type
= die_type (die
, cu
);
20213 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
20214 if (result
== NULL
)
20215 result
= write_constant_as_bytes (obstack
, byte_order
,
20219 case DW_FORM_sdata
:
20220 type
= die_type (die
, cu
);
20221 result
= write_constant_as_bytes (obstack
, byte_order
,
20222 type
, DW_SND (attr
), len
);
20225 case DW_FORM_udata
:
20226 type
= die_type (die
, cu
);
20227 result
= write_constant_as_bytes (obstack
, byte_order
,
20228 type
, DW_UNSND (attr
), len
);
20232 complaint (&symfile_complaints
,
20233 _("unsupported const value attribute form: '%s'"),
20234 dwarf_form_name (attr
->form
));
20241 /* Return the type of the DIE at DIE_OFFSET in the CU named by
20245 dwarf2_get_die_type (cu_offset die_offset
,
20246 struct dwarf2_per_cu_data
*per_cu
)
20248 sect_offset die_offset_sect
;
20250 dw2_setup (per_cu
->objfile
);
20252 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
20253 return get_die_type_at_offset (die_offset_sect
, per_cu
);
20256 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
20257 On entry *REF_CU is the CU of SRC_DIE.
20258 On exit *REF_CU is the CU of the result.
20259 Returns NULL if the referenced DIE isn't found. */
20261 static struct die_info
*
20262 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
20263 struct dwarf2_cu
**ref_cu
)
20265 struct objfile
*objfile
= (*ref_cu
)->objfile
;
20266 struct die_info temp_die
;
20267 struct dwarf2_cu
*sig_cu
;
20268 struct die_info
*die
;
20270 /* While it might be nice to assert sig_type->type == NULL here,
20271 we can get here for DW_AT_imported_declaration where we need
20272 the DIE not the type. */
20274 /* If necessary, add it to the queue and load its DIEs. */
20276 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
20277 read_signatured_type (sig_type
);
20279 sig_cu
= sig_type
->per_cu
.cu
;
20280 gdb_assert (sig_cu
!= NULL
);
20281 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
20282 temp_die
.offset
= sig_type
->type_offset_in_section
;
20283 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
20284 temp_die
.offset
.sect_off
);
20287 /* For .gdb_index version 7 keep track of included TUs.
20288 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
20289 if (dwarf2_per_objfile
->index_table
!= NULL
20290 && dwarf2_per_objfile
->index_table
->version
<= 7)
20292 VEC_safe_push (dwarf2_per_cu_ptr
,
20293 (*ref_cu
)->per_cu
->imported_symtabs
,
20304 /* Follow signatured type referenced by ATTR in SRC_DIE.
20305 On entry *REF_CU is the CU of SRC_DIE.
20306 On exit *REF_CU is the CU of the result.
20307 The result is the DIE of the type.
20308 If the referenced type cannot be found an error is thrown. */
20310 static struct die_info
*
20311 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
20312 struct dwarf2_cu
**ref_cu
)
20314 ULONGEST signature
= DW_SIGNATURE (attr
);
20315 struct signatured_type
*sig_type
;
20316 struct die_info
*die
;
20318 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
20320 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
20321 /* sig_type will be NULL if the signatured type is missing from
20323 if (sig_type
== NULL
)
20325 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
20326 " from DIE at 0x%x [in module %s]"),
20327 hex_string (signature
), src_die
->offset
.sect_off
,
20328 objfile_name ((*ref_cu
)->objfile
));
20331 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
20334 dump_die_for_error (src_die
);
20335 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
20336 " from DIE at 0x%x [in module %s]"),
20337 hex_string (signature
), src_die
->offset
.sect_off
,
20338 objfile_name ((*ref_cu
)->objfile
));
20344 /* Get the type specified by SIGNATURE referenced in DIE/CU,
20345 reading in and processing the type unit if necessary. */
20347 static struct type
*
20348 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
20349 struct dwarf2_cu
*cu
)
20351 struct signatured_type
*sig_type
;
20352 struct dwarf2_cu
*type_cu
;
20353 struct die_info
*type_die
;
20356 sig_type
= lookup_signatured_type (cu
, signature
);
20357 /* sig_type will be NULL if the signatured type is missing from
20359 if (sig_type
== NULL
)
20361 complaint (&symfile_complaints
,
20362 _("Dwarf Error: Cannot find signatured DIE %s referenced"
20363 " from DIE at 0x%x [in module %s]"),
20364 hex_string (signature
), die
->offset
.sect_off
,
20365 objfile_name (dwarf2_per_objfile
->objfile
));
20366 return build_error_marker_type (cu
, die
);
20369 /* If we already know the type we're done. */
20370 if (sig_type
->type
!= NULL
)
20371 return sig_type
->type
;
20374 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
20375 if (type_die
!= NULL
)
20377 /* N.B. We need to call get_die_type to ensure only one type for this DIE
20378 is created. This is important, for example, because for c++ classes
20379 we need TYPE_NAME set which is only done by new_symbol. Blech. */
20380 type
= read_type_die (type_die
, type_cu
);
20383 complaint (&symfile_complaints
,
20384 _("Dwarf Error: Cannot build signatured type %s"
20385 " referenced from DIE at 0x%x [in module %s]"),
20386 hex_string (signature
), die
->offset
.sect_off
,
20387 objfile_name (dwarf2_per_objfile
->objfile
));
20388 type
= build_error_marker_type (cu
, die
);
20393 complaint (&symfile_complaints
,
20394 _("Dwarf Error: Problem reading signatured DIE %s referenced"
20395 " from DIE at 0x%x [in module %s]"),
20396 hex_string (signature
), die
->offset
.sect_off
,
20397 objfile_name (dwarf2_per_objfile
->objfile
));
20398 type
= build_error_marker_type (cu
, die
);
20400 sig_type
->type
= type
;
20405 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
20406 reading in and processing the type unit if necessary. */
20408 static struct type
*
20409 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
20410 struct dwarf2_cu
*cu
) /* ARI: editCase function */
20412 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
20413 if (attr_form_is_ref (attr
))
20415 struct dwarf2_cu
*type_cu
= cu
;
20416 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
20418 return read_type_die (type_die
, type_cu
);
20420 else if (attr
->form
== DW_FORM_ref_sig8
)
20422 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
20426 complaint (&symfile_complaints
,
20427 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
20428 " at 0x%x [in module %s]"),
20429 dwarf_form_name (attr
->form
), die
->offset
.sect_off
,
20430 objfile_name (dwarf2_per_objfile
->objfile
));
20431 return build_error_marker_type (cu
, die
);
20435 /* Load the DIEs associated with type unit PER_CU into memory. */
20438 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
20440 struct signatured_type
*sig_type
;
20442 /* Caller is responsible for ensuring type_unit_groups don't get here. */
20443 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
20445 /* We have the per_cu, but we need the signatured_type.
20446 Fortunately this is an easy translation. */
20447 gdb_assert (per_cu
->is_debug_types
);
20448 sig_type
= (struct signatured_type
*) per_cu
;
20450 gdb_assert (per_cu
->cu
== NULL
);
20452 read_signatured_type (sig_type
);
20454 gdb_assert (per_cu
->cu
!= NULL
);
20457 /* die_reader_func for read_signatured_type.
20458 This is identical to load_full_comp_unit_reader,
20459 but is kept separate for now. */
20462 read_signatured_type_reader (const struct die_reader_specs
*reader
,
20463 const gdb_byte
*info_ptr
,
20464 struct die_info
*comp_unit_die
,
20468 struct dwarf2_cu
*cu
= reader
->cu
;
20470 gdb_assert (cu
->die_hash
== NULL
);
20472 htab_create_alloc_ex (cu
->header
.length
/ 12,
20476 &cu
->comp_unit_obstack
,
20477 hashtab_obstack_allocate
,
20478 dummy_obstack_deallocate
);
20481 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
20482 &info_ptr
, comp_unit_die
);
20483 cu
->dies
= comp_unit_die
;
20484 /* comp_unit_die is not stored in die_hash, no need. */
20486 /* We try not to read any attributes in this function, because not
20487 all CUs needed for references have been loaded yet, and symbol
20488 table processing isn't initialized. But we have to set the CU language,
20489 or we won't be able to build types correctly.
20490 Similarly, if we do not read the producer, we can not apply
20491 producer-specific interpretation. */
20492 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
20495 /* Read in a signatured type and build its CU and DIEs.
20496 If the type is a stub for the real type in a DWO file,
20497 read in the real type from the DWO file as well. */
20500 read_signatured_type (struct signatured_type
*sig_type
)
20502 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
20504 gdb_assert (per_cu
->is_debug_types
);
20505 gdb_assert (per_cu
->cu
== NULL
);
20507 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
20508 read_signatured_type_reader
, NULL
);
20509 sig_type
->per_cu
.tu_read
= 1;
20512 /* Decode simple location descriptions.
20513 Given a pointer to a dwarf block that defines a location, compute
20514 the location and return the value.
20516 NOTE drow/2003-11-18: This function is called in two situations
20517 now: for the address of static or global variables (partial symbols
20518 only) and for offsets into structures which are expected to be
20519 (more or less) constant. The partial symbol case should go away,
20520 and only the constant case should remain. That will let this
20521 function complain more accurately. A few special modes are allowed
20522 without complaint for global variables (for instance, global
20523 register values and thread-local values).
20525 A location description containing no operations indicates that the
20526 object is optimized out. The return value is 0 for that case.
20527 FIXME drow/2003-11-16: No callers check for this case any more; soon all
20528 callers will only want a very basic result and this can become a
20531 Note that stack[0] is unused except as a default error return. */
20534 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
20536 struct objfile
*objfile
= cu
->objfile
;
20538 size_t size
= blk
->size
;
20539 const gdb_byte
*data
= blk
->data
;
20540 CORE_ADDR stack
[64];
20542 unsigned int bytes_read
, unsnd
;
20548 stack
[++stacki
] = 0;
20587 stack
[++stacki
] = op
- DW_OP_lit0
;
20622 stack
[++stacki
] = op
- DW_OP_reg0
;
20624 dwarf2_complex_location_expr_complaint ();
20628 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
20630 stack
[++stacki
] = unsnd
;
20632 dwarf2_complex_location_expr_complaint ();
20636 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
20641 case DW_OP_const1u
:
20642 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
20646 case DW_OP_const1s
:
20647 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
20651 case DW_OP_const2u
:
20652 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
20656 case DW_OP_const2s
:
20657 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
20661 case DW_OP_const4u
:
20662 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
20666 case DW_OP_const4s
:
20667 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
20671 case DW_OP_const8u
:
20672 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
20677 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
20683 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
20688 stack
[stacki
+ 1] = stack
[stacki
];
20693 stack
[stacki
- 1] += stack
[stacki
];
20697 case DW_OP_plus_uconst
:
20698 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
20704 stack
[stacki
- 1] -= stack
[stacki
];
20709 /* If we're not the last op, then we definitely can't encode
20710 this using GDB's address_class enum. This is valid for partial
20711 global symbols, although the variable's address will be bogus
20714 dwarf2_complex_location_expr_complaint ();
20717 case DW_OP_GNU_push_tls_address
:
20718 /* The top of the stack has the offset from the beginning
20719 of the thread control block at which the variable is located. */
20720 /* Nothing should follow this operator, so the top of stack would
20722 /* This is valid for partial global symbols, but the variable's
20723 address will be bogus in the psymtab. Make it always at least
20724 non-zero to not look as a variable garbage collected by linker
20725 which have DW_OP_addr 0. */
20727 dwarf2_complex_location_expr_complaint ();
20731 case DW_OP_GNU_uninit
:
20734 case DW_OP_GNU_addr_index
:
20735 case DW_OP_GNU_const_index
:
20736 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
20743 const char *name
= get_DW_OP_name (op
);
20746 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
20749 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
20753 return (stack
[stacki
]);
20756 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20757 outside of the allocated space. Also enforce minimum>0. */
20758 if (stacki
>= ARRAY_SIZE (stack
) - 1)
20760 complaint (&symfile_complaints
,
20761 _("location description stack overflow"));
20767 complaint (&symfile_complaints
,
20768 _("location description stack underflow"));
20772 return (stack
[stacki
]);
20775 /* memory allocation interface */
20777 static struct dwarf_block
*
20778 dwarf_alloc_block (struct dwarf2_cu
*cu
)
20780 struct dwarf_block
*blk
;
20782 blk
= (struct dwarf_block
*)
20783 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
20787 static struct die_info
*
20788 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
20790 struct die_info
*die
;
20791 size_t size
= sizeof (struct die_info
);
20794 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
20796 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
20797 memset (die
, 0, sizeof (struct die_info
));
20802 /* Macro support. */
20804 /* Return file name relative to the compilation directory of file number I in
20805 *LH's file name table. The result is allocated using xmalloc; the caller is
20806 responsible for freeing it. */
20809 file_file_name (int file
, struct line_header
*lh
)
20811 /* Is the file number a valid index into the line header's file name
20812 table? Remember that file numbers start with one, not zero. */
20813 if (1 <= file
&& file
<= lh
->num_file_names
)
20815 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
20817 if (IS_ABSOLUTE_PATH (fe
->name
) || fe
->dir_index
== 0
20818 || lh
->include_dirs
== NULL
)
20819 return xstrdup (fe
->name
);
20820 return concat (lh
->include_dirs
[fe
->dir_index
- 1], SLASH_STRING
,
20825 /* The compiler produced a bogus file number. We can at least
20826 record the macro definitions made in the file, even if we
20827 won't be able to find the file by name. */
20828 char fake_name
[80];
20830 xsnprintf (fake_name
, sizeof (fake_name
),
20831 "<bad macro file number %d>", file
);
20833 complaint (&symfile_complaints
,
20834 _("bad file number in macro information (%d)"),
20837 return xstrdup (fake_name
);
20841 /* Return the full name of file number I in *LH's file name table.
20842 Use COMP_DIR as the name of the current directory of the
20843 compilation. The result is allocated using xmalloc; the caller is
20844 responsible for freeing it. */
20846 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
20848 /* Is the file number a valid index into the line header's file name
20849 table? Remember that file numbers start with one, not zero. */
20850 if (1 <= file
&& file
<= lh
->num_file_names
)
20852 char *relative
= file_file_name (file
, lh
);
20854 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
20856 return reconcat (relative
, comp_dir
, SLASH_STRING
, relative
, NULL
);
20859 return file_file_name (file
, lh
);
20863 static struct macro_source_file
*
20864 macro_start_file (int file
, int line
,
20865 struct macro_source_file
*current_file
,
20866 struct line_header
*lh
)
20868 /* File name relative to the compilation directory of this source file. */
20869 char *file_name
= file_file_name (file
, lh
);
20871 if (! current_file
)
20873 /* Note: We don't create a macro table for this compilation unit
20874 at all until we actually get a filename. */
20875 struct macro_table
*macro_table
= get_macro_table ();
20877 /* If we have no current file, then this must be the start_file
20878 directive for the compilation unit's main source file. */
20879 current_file
= macro_set_main (macro_table
, file_name
);
20880 macro_define_special (macro_table
);
20883 current_file
= macro_include (current_file
, line
, file_name
);
20887 return current_file
;
20891 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20892 followed by a null byte. */
20894 copy_string (const char *buf
, int len
)
20896 char *s
= xmalloc (len
+ 1);
20898 memcpy (s
, buf
, len
);
20904 static const char *
20905 consume_improper_spaces (const char *p
, const char *body
)
20909 complaint (&symfile_complaints
,
20910 _("macro definition contains spaces "
20911 "in formal argument list:\n`%s'"),
20923 parse_macro_definition (struct macro_source_file
*file
, int line
,
20928 /* The body string takes one of two forms. For object-like macro
20929 definitions, it should be:
20931 <macro name> " " <definition>
20933 For function-like macro definitions, it should be:
20935 <macro name> "() " <definition>
20937 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20939 Spaces may appear only where explicitly indicated, and in the
20942 The Dwarf 2 spec says that an object-like macro's name is always
20943 followed by a space, but versions of GCC around March 2002 omit
20944 the space when the macro's definition is the empty string.
20946 The Dwarf 2 spec says that there should be no spaces between the
20947 formal arguments in a function-like macro's formal argument list,
20948 but versions of GCC around March 2002 include spaces after the
20952 /* Find the extent of the macro name. The macro name is terminated
20953 by either a space or null character (for an object-like macro) or
20954 an opening paren (for a function-like macro). */
20955 for (p
= body
; *p
; p
++)
20956 if (*p
== ' ' || *p
== '(')
20959 if (*p
== ' ' || *p
== '\0')
20961 /* It's an object-like macro. */
20962 int name_len
= p
- body
;
20963 char *name
= copy_string (body
, name_len
);
20964 const char *replacement
;
20967 replacement
= body
+ name_len
+ 1;
20970 dwarf2_macro_malformed_definition_complaint (body
);
20971 replacement
= body
+ name_len
;
20974 macro_define_object (file
, line
, name
, replacement
);
20978 else if (*p
== '(')
20980 /* It's a function-like macro. */
20981 char *name
= copy_string (body
, p
- body
);
20984 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
20988 p
= consume_improper_spaces (p
, body
);
20990 /* Parse the formal argument list. */
20991 while (*p
&& *p
!= ')')
20993 /* Find the extent of the current argument name. */
20994 const char *arg_start
= p
;
20996 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
20999 if (! *p
|| p
== arg_start
)
21000 dwarf2_macro_malformed_definition_complaint (body
);
21003 /* Make sure argv has room for the new argument. */
21004 if (argc
>= argv_size
)
21007 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
21010 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
21013 p
= consume_improper_spaces (p
, body
);
21015 /* Consume the comma, if present. */
21020 p
= consume_improper_spaces (p
, body
);
21029 /* Perfectly formed definition, no complaints. */
21030 macro_define_function (file
, line
, name
,
21031 argc
, (const char **) argv
,
21033 else if (*p
== '\0')
21035 /* Complain, but do define it. */
21036 dwarf2_macro_malformed_definition_complaint (body
);
21037 macro_define_function (file
, line
, name
,
21038 argc
, (const char **) argv
,
21042 /* Just complain. */
21043 dwarf2_macro_malformed_definition_complaint (body
);
21046 /* Just complain. */
21047 dwarf2_macro_malformed_definition_complaint (body
);
21053 for (i
= 0; i
< argc
; i
++)
21059 dwarf2_macro_malformed_definition_complaint (body
);
21062 /* Skip some bytes from BYTES according to the form given in FORM.
21063 Returns the new pointer. */
21065 static const gdb_byte
*
21066 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
21067 enum dwarf_form form
,
21068 unsigned int offset_size
,
21069 struct dwarf2_section_info
*section
)
21071 unsigned int bytes_read
;
21075 case DW_FORM_data1
:
21080 case DW_FORM_data2
:
21084 case DW_FORM_data4
:
21088 case DW_FORM_data8
:
21092 case DW_FORM_string
:
21093 read_direct_string (abfd
, bytes
, &bytes_read
);
21094 bytes
+= bytes_read
;
21097 case DW_FORM_sec_offset
:
21099 case DW_FORM_GNU_strp_alt
:
21100 bytes
+= offset_size
;
21103 case DW_FORM_block
:
21104 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
21105 bytes
+= bytes_read
;
21108 case DW_FORM_block1
:
21109 bytes
+= 1 + read_1_byte (abfd
, bytes
);
21111 case DW_FORM_block2
:
21112 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
21114 case DW_FORM_block4
:
21115 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
21118 case DW_FORM_sdata
:
21119 case DW_FORM_udata
:
21120 case DW_FORM_GNU_addr_index
:
21121 case DW_FORM_GNU_str_index
:
21122 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
21125 dwarf2_section_buffer_overflow_complaint (section
);
21133 complaint (&symfile_complaints
,
21134 _("invalid form 0x%x in `%s'"),
21135 form
, get_section_name (section
));
21143 /* A helper for dwarf_decode_macros that handles skipping an unknown
21144 opcode. Returns an updated pointer to the macro data buffer; or,
21145 on error, issues a complaint and returns NULL. */
21147 static const gdb_byte
*
21148 skip_unknown_opcode (unsigned int opcode
,
21149 const gdb_byte
**opcode_definitions
,
21150 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21152 unsigned int offset_size
,
21153 struct dwarf2_section_info
*section
)
21155 unsigned int bytes_read
, i
;
21157 const gdb_byte
*defn
;
21159 if (opcode_definitions
[opcode
] == NULL
)
21161 complaint (&symfile_complaints
,
21162 _("unrecognized DW_MACFINO opcode 0x%x"),
21167 defn
= opcode_definitions
[opcode
];
21168 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
21169 defn
+= bytes_read
;
21171 for (i
= 0; i
< arg
; ++i
)
21173 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
, defn
[i
], offset_size
,
21175 if (mac_ptr
== NULL
)
21177 /* skip_form_bytes already issued the complaint. */
21185 /* A helper function which parses the header of a macro section.
21186 If the macro section is the extended (for now called "GNU") type,
21187 then this updates *OFFSET_SIZE. Returns a pointer to just after
21188 the header, or issues a complaint and returns NULL on error. */
21190 static const gdb_byte
*
21191 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
21193 const gdb_byte
*mac_ptr
,
21194 unsigned int *offset_size
,
21195 int section_is_gnu
)
21197 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
21199 if (section_is_gnu
)
21201 unsigned int version
, flags
;
21203 version
= read_2_bytes (abfd
, mac_ptr
);
21206 complaint (&symfile_complaints
,
21207 _("unrecognized version `%d' in .debug_macro section"),
21213 flags
= read_1_byte (abfd
, mac_ptr
);
21215 *offset_size
= (flags
& 1) ? 8 : 4;
21217 if ((flags
& 2) != 0)
21218 /* We don't need the line table offset. */
21219 mac_ptr
+= *offset_size
;
21221 /* Vendor opcode descriptions. */
21222 if ((flags
& 4) != 0)
21224 unsigned int i
, count
;
21226 count
= read_1_byte (abfd
, mac_ptr
);
21228 for (i
= 0; i
< count
; ++i
)
21230 unsigned int opcode
, bytes_read
;
21233 opcode
= read_1_byte (abfd
, mac_ptr
);
21235 opcode_definitions
[opcode
] = mac_ptr
;
21236 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21237 mac_ptr
+= bytes_read
;
21246 /* A helper for dwarf_decode_macros that handles the GNU extensions,
21247 including DW_MACRO_GNU_transparent_include. */
21250 dwarf_decode_macro_bytes (bfd
*abfd
,
21251 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
21252 struct macro_source_file
*current_file
,
21253 struct line_header
*lh
,
21254 struct dwarf2_section_info
*section
,
21255 int section_is_gnu
, int section_is_dwz
,
21256 unsigned int offset_size
,
21257 htab_t include_hash
)
21259 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21260 enum dwarf_macro_record_type macinfo_type
;
21261 int at_commandline
;
21262 const gdb_byte
*opcode_definitions
[256];
21264 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21265 &offset_size
, section_is_gnu
);
21266 if (mac_ptr
== NULL
)
21268 /* We already issued a complaint. */
21272 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
21273 GDB is still reading the definitions from command line. First
21274 DW_MACINFO_start_file will need to be ignored as it was already executed
21275 to create CURRENT_FILE for the main source holding also the command line
21276 definitions. On first met DW_MACINFO_start_file this flag is reset to
21277 normally execute all the remaining DW_MACINFO_start_file macinfos. */
21279 at_commandline
= 1;
21283 /* Do we at least have room for a macinfo type byte? */
21284 if (mac_ptr
>= mac_end
)
21286 dwarf2_section_buffer_overflow_complaint (section
);
21290 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
21293 /* Note that we rely on the fact that the corresponding GNU and
21294 DWARF constants are the same. */
21295 switch (macinfo_type
)
21297 /* A zero macinfo type indicates the end of the macro
21302 case DW_MACRO_GNU_define
:
21303 case DW_MACRO_GNU_undef
:
21304 case DW_MACRO_GNU_define_indirect
:
21305 case DW_MACRO_GNU_undef_indirect
:
21306 case DW_MACRO_GNU_define_indirect_alt
:
21307 case DW_MACRO_GNU_undef_indirect_alt
:
21309 unsigned int bytes_read
;
21314 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21315 mac_ptr
+= bytes_read
;
21317 if (macinfo_type
== DW_MACRO_GNU_define
21318 || macinfo_type
== DW_MACRO_GNU_undef
)
21320 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21321 mac_ptr
+= bytes_read
;
21325 LONGEST str_offset
;
21327 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21328 mac_ptr
+= offset_size
;
21330 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
21331 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
21334 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21336 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
21339 body
= read_indirect_string_at_offset (abfd
, str_offset
);
21342 is_define
= (macinfo_type
== DW_MACRO_GNU_define
21343 || macinfo_type
== DW_MACRO_GNU_define_indirect
21344 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
21345 if (! current_file
)
21347 /* DWARF violation as no main source is present. */
21348 complaint (&symfile_complaints
,
21349 _("debug info with no main source gives macro %s "
21351 is_define
? _("definition") : _("undefinition"),
21355 if ((line
== 0 && !at_commandline
)
21356 || (line
!= 0 && at_commandline
))
21357 complaint (&symfile_complaints
,
21358 _("debug info gives %s macro %s with %s line %d: %s"),
21359 at_commandline
? _("command-line") : _("in-file"),
21360 is_define
? _("definition") : _("undefinition"),
21361 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
21364 parse_macro_definition (current_file
, line
, body
);
21367 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
21368 || macinfo_type
== DW_MACRO_GNU_undef_indirect
21369 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
21370 macro_undef (current_file
, line
, body
);
21375 case DW_MACRO_GNU_start_file
:
21377 unsigned int bytes_read
;
21380 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21381 mac_ptr
+= bytes_read
;
21382 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21383 mac_ptr
+= bytes_read
;
21385 if ((line
== 0 && !at_commandline
)
21386 || (line
!= 0 && at_commandline
))
21387 complaint (&symfile_complaints
,
21388 _("debug info gives source %d included "
21389 "from %s at %s line %d"),
21390 file
, at_commandline
? _("command-line") : _("file"),
21391 line
== 0 ? _("zero") : _("non-zero"), line
);
21393 if (at_commandline
)
21395 /* This DW_MACRO_GNU_start_file was executed in the
21397 at_commandline
= 0;
21400 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21404 case DW_MACRO_GNU_end_file
:
21405 if (! current_file
)
21406 complaint (&symfile_complaints
,
21407 _("macro debug info has an unmatched "
21408 "`close_file' directive"));
21411 current_file
= current_file
->included_by
;
21412 if (! current_file
)
21414 enum dwarf_macro_record_type next_type
;
21416 /* GCC circa March 2002 doesn't produce the zero
21417 type byte marking the end of the compilation
21418 unit. Complain if it's not there, but exit no
21421 /* Do we at least have room for a macinfo type byte? */
21422 if (mac_ptr
>= mac_end
)
21424 dwarf2_section_buffer_overflow_complaint (section
);
21428 /* We don't increment mac_ptr here, so this is just
21430 next_type
= read_1_byte (abfd
, mac_ptr
);
21431 if (next_type
!= 0)
21432 complaint (&symfile_complaints
,
21433 _("no terminating 0-type entry for "
21434 "macros in `.debug_macinfo' section"));
21441 case DW_MACRO_GNU_transparent_include
:
21442 case DW_MACRO_GNU_transparent_include_alt
:
21446 bfd
*include_bfd
= abfd
;
21447 struct dwarf2_section_info
*include_section
= section
;
21448 struct dwarf2_section_info alt_section
;
21449 const gdb_byte
*include_mac_end
= mac_end
;
21450 int is_dwz
= section_is_dwz
;
21451 const gdb_byte
*new_mac_ptr
;
21453 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
21454 mac_ptr
+= offset_size
;
21456 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
21458 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
21460 dwarf2_read_section (objfile
, &dwz
->macro
);
21462 include_section
= &dwz
->macro
;
21463 include_bfd
= get_section_bfd_owner (include_section
);
21464 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
21468 new_mac_ptr
= include_section
->buffer
+ offset
;
21469 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
21473 /* This has actually happened; see
21474 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
21475 complaint (&symfile_complaints
,
21476 _("recursive DW_MACRO_GNU_transparent_include in "
21477 ".debug_macro section"));
21481 *slot
= (void *) new_mac_ptr
;
21483 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
21484 include_mac_end
, current_file
, lh
,
21485 section
, section_is_gnu
, is_dwz
,
21486 offset_size
, include_hash
);
21488 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
21493 case DW_MACINFO_vendor_ext
:
21494 if (!section_is_gnu
)
21496 unsigned int bytes_read
;
21499 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21500 mac_ptr
+= bytes_read
;
21501 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21502 mac_ptr
+= bytes_read
;
21504 /* We don't recognize any vendor extensions. */
21510 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21511 mac_ptr
, mac_end
, abfd
, offset_size
,
21513 if (mac_ptr
== NULL
)
21517 } while (macinfo_type
!= 0);
21521 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
21522 int section_is_gnu
)
21524 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21525 struct line_header
*lh
= cu
->line_header
;
21527 const gdb_byte
*mac_ptr
, *mac_end
;
21528 struct macro_source_file
*current_file
= 0;
21529 enum dwarf_macro_record_type macinfo_type
;
21530 unsigned int offset_size
= cu
->header
.offset_size
;
21531 const gdb_byte
*opcode_definitions
[256];
21532 struct cleanup
*cleanup
;
21533 htab_t include_hash
;
21535 struct dwarf2_section_info
*section
;
21536 const char *section_name
;
21538 if (cu
->dwo_unit
!= NULL
)
21540 if (section_is_gnu
)
21542 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
21543 section_name
= ".debug_macro.dwo";
21547 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
21548 section_name
= ".debug_macinfo.dwo";
21553 if (section_is_gnu
)
21555 section
= &dwarf2_per_objfile
->macro
;
21556 section_name
= ".debug_macro";
21560 section
= &dwarf2_per_objfile
->macinfo
;
21561 section_name
= ".debug_macinfo";
21565 dwarf2_read_section (objfile
, section
);
21566 if (section
->buffer
== NULL
)
21568 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
21571 abfd
= get_section_bfd_owner (section
);
21573 /* First pass: Find the name of the base filename.
21574 This filename is needed in order to process all macros whose definition
21575 (or undefinition) comes from the command line. These macros are defined
21576 before the first DW_MACINFO_start_file entry, and yet still need to be
21577 associated to the base file.
21579 To determine the base file name, we scan the macro definitions until we
21580 reach the first DW_MACINFO_start_file entry. We then initialize
21581 CURRENT_FILE accordingly so that any macro definition found before the
21582 first DW_MACINFO_start_file can still be associated to the base file. */
21584 mac_ptr
= section
->buffer
+ offset
;
21585 mac_end
= section
->buffer
+ section
->size
;
21587 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
21588 &offset_size
, section_is_gnu
);
21589 if (mac_ptr
== NULL
)
21591 /* We already issued a complaint. */
21597 /* Do we at least have room for a macinfo type byte? */
21598 if (mac_ptr
>= mac_end
)
21600 /* Complaint is printed during the second pass as GDB will probably
21601 stop the first pass earlier upon finding
21602 DW_MACINFO_start_file. */
21606 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
21609 /* Note that we rely on the fact that the corresponding GNU and
21610 DWARF constants are the same. */
21611 switch (macinfo_type
)
21613 /* A zero macinfo type indicates the end of the macro
21618 case DW_MACRO_GNU_define
:
21619 case DW_MACRO_GNU_undef
:
21620 /* Only skip the data by MAC_PTR. */
21622 unsigned int bytes_read
;
21624 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21625 mac_ptr
+= bytes_read
;
21626 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21627 mac_ptr
+= bytes_read
;
21631 case DW_MACRO_GNU_start_file
:
21633 unsigned int bytes_read
;
21636 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21637 mac_ptr
+= bytes_read
;
21638 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21639 mac_ptr
+= bytes_read
;
21641 current_file
= macro_start_file (file
, line
, current_file
, lh
);
21645 case DW_MACRO_GNU_end_file
:
21646 /* No data to skip by MAC_PTR. */
21649 case DW_MACRO_GNU_define_indirect
:
21650 case DW_MACRO_GNU_undef_indirect
:
21651 case DW_MACRO_GNU_define_indirect_alt
:
21652 case DW_MACRO_GNU_undef_indirect_alt
:
21654 unsigned int bytes_read
;
21656 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21657 mac_ptr
+= bytes_read
;
21658 mac_ptr
+= offset_size
;
21662 case DW_MACRO_GNU_transparent_include
:
21663 case DW_MACRO_GNU_transparent_include_alt
:
21664 /* Note that, according to the spec, a transparent include
21665 chain cannot call DW_MACRO_GNU_start_file. So, we can just
21666 skip this opcode. */
21667 mac_ptr
+= offset_size
;
21670 case DW_MACINFO_vendor_ext
:
21671 /* Only skip the data by MAC_PTR. */
21672 if (!section_is_gnu
)
21674 unsigned int bytes_read
;
21676 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
21677 mac_ptr
+= bytes_read
;
21678 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
21679 mac_ptr
+= bytes_read
;
21684 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
21685 mac_ptr
, mac_end
, abfd
, offset_size
,
21687 if (mac_ptr
== NULL
)
21691 } while (macinfo_type
!= 0 && current_file
== NULL
);
21693 /* Second pass: Process all entries.
21695 Use the AT_COMMAND_LINE flag to determine whether we are still processing
21696 command-line macro definitions/undefinitions. This flag is unset when we
21697 reach the first DW_MACINFO_start_file entry. */
21699 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
21700 NULL
, xcalloc
, xfree
);
21701 cleanup
= make_cleanup_htab_delete (include_hash
);
21702 mac_ptr
= section
->buffer
+ offset
;
21703 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
21704 *slot
= (void *) mac_ptr
;
21705 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
21706 current_file
, lh
, section
,
21707 section_is_gnu
, 0, offset_size
, include_hash
);
21708 do_cleanups (cleanup
);
21711 /* Check if the attribute's form is a DW_FORM_block*
21712 if so return true else false. */
21715 attr_form_is_block (const struct attribute
*attr
)
21717 return (attr
== NULL
? 0 :
21718 attr
->form
== DW_FORM_block1
21719 || attr
->form
== DW_FORM_block2
21720 || attr
->form
== DW_FORM_block4
21721 || attr
->form
== DW_FORM_block
21722 || attr
->form
== DW_FORM_exprloc
);
21725 /* Return non-zero if ATTR's value is a section offset --- classes
21726 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21727 You may use DW_UNSND (attr) to retrieve such offsets.
21729 Section 7.5.4, "Attribute Encodings", explains that no attribute
21730 may have a value that belongs to more than one of these classes; it
21731 would be ambiguous if we did, because we use the same forms for all
21735 attr_form_is_section_offset (const struct attribute
*attr
)
21737 return (attr
->form
== DW_FORM_data4
21738 || attr
->form
== DW_FORM_data8
21739 || attr
->form
== DW_FORM_sec_offset
);
21742 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21743 zero otherwise. When this function returns true, you can apply
21744 dwarf2_get_attr_constant_value to it.
21746 However, note that for some attributes you must check
21747 attr_form_is_section_offset before using this test. DW_FORM_data4
21748 and DW_FORM_data8 are members of both the constant class, and of
21749 the classes that contain offsets into other debug sections
21750 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21751 that, if an attribute's can be either a constant or one of the
21752 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21753 taken as section offsets, not constants. */
21756 attr_form_is_constant (const struct attribute
*attr
)
21758 switch (attr
->form
)
21760 case DW_FORM_sdata
:
21761 case DW_FORM_udata
:
21762 case DW_FORM_data1
:
21763 case DW_FORM_data2
:
21764 case DW_FORM_data4
:
21765 case DW_FORM_data8
:
21773 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21774 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21777 attr_form_is_ref (const struct attribute
*attr
)
21779 switch (attr
->form
)
21781 case DW_FORM_ref_addr
:
21786 case DW_FORM_ref_udata
:
21787 case DW_FORM_GNU_ref_alt
:
21794 /* Return the .debug_loc section to use for CU.
21795 For DWO files use .debug_loc.dwo. */
21797 static struct dwarf2_section_info
*
21798 cu_debug_loc_section (struct dwarf2_cu
*cu
)
21801 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
21802 return &dwarf2_per_objfile
->loc
;
21805 /* A helper function that fills in a dwarf2_loclist_baton. */
21808 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
21809 struct dwarf2_loclist_baton
*baton
,
21810 const struct attribute
*attr
)
21812 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21814 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
21816 baton
->per_cu
= cu
->per_cu
;
21817 gdb_assert (baton
->per_cu
);
21818 /* We don't know how long the location list is, but make sure we
21819 don't run off the edge of the section. */
21820 baton
->size
= section
->size
- DW_UNSND (attr
);
21821 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
21822 baton
->base_address
= cu
->base_address
;
21823 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
21827 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
21828 struct dwarf2_cu
*cu
, int is_block
)
21830 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21831 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
21833 if (attr_form_is_section_offset (attr
)
21834 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21835 the section. If so, fall through to the complaint in the
21837 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
21839 struct dwarf2_loclist_baton
*baton
;
21841 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21842 sizeof (struct dwarf2_loclist_baton
));
21844 fill_in_loclist_baton (cu
, baton
, attr
);
21846 if (cu
->base_known
== 0)
21847 complaint (&symfile_complaints
,
21848 _("Location list used without "
21849 "specifying the CU base address."));
21851 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21852 ? dwarf2_loclist_block_index
21853 : dwarf2_loclist_index
);
21854 SYMBOL_LOCATION_BATON (sym
) = baton
;
21858 struct dwarf2_locexpr_baton
*baton
;
21860 baton
= obstack_alloc (&objfile
->objfile_obstack
,
21861 sizeof (struct dwarf2_locexpr_baton
));
21862 baton
->per_cu
= cu
->per_cu
;
21863 gdb_assert (baton
->per_cu
);
21865 if (attr_form_is_block (attr
))
21867 /* Note that we're just copying the block's data pointer
21868 here, not the actual data. We're still pointing into the
21869 info_buffer for SYM's objfile; right now we never release
21870 that buffer, but when we do clean up properly this may
21872 baton
->size
= DW_BLOCK (attr
)->size
;
21873 baton
->data
= DW_BLOCK (attr
)->data
;
21877 dwarf2_invalid_attrib_class_complaint ("location description",
21878 SYMBOL_NATURAL_NAME (sym
));
21882 SYMBOL_ACLASS_INDEX (sym
) = (is_block
21883 ? dwarf2_locexpr_block_index
21884 : dwarf2_locexpr_index
);
21885 SYMBOL_LOCATION_BATON (sym
) = baton
;
21889 /* Return the OBJFILE associated with the compilation unit CU. If CU
21890 came from a separate debuginfo file, then the master objfile is
21894 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
21896 struct objfile
*objfile
= per_cu
->objfile
;
21898 /* Return the master objfile, so that we can report and look up the
21899 correct file containing this variable. */
21900 if (objfile
->separate_debug_objfile_backlink
)
21901 objfile
= objfile
->separate_debug_objfile_backlink
;
21906 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21907 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21908 CU_HEADERP first. */
21910 static const struct comp_unit_head
*
21911 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
21912 struct dwarf2_per_cu_data
*per_cu
)
21914 const gdb_byte
*info_ptr
;
21917 return &per_cu
->cu
->header
;
21919 info_ptr
= per_cu
->section
->buffer
+ per_cu
->offset
.sect_off
;
21921 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
21922 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
21927 /* Return the address size given in the compilation unit header for CU. */
21930 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21932 struct comp_unit_head cu_header_local
;
21933 const struct comp_unit_head
*cu_headerp
;
21935 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21937 return cu_headerp
->addr_size
;
21940 /* Return the offset size given in the compilation unit header for CU. */
21943 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
21945 struct comp_unit_head cu_header_local
;
21946 const struct comp_unit_head
*cu_headerp
;
21948 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21950 return cu_headerp
->offset_size
;
21953 /* See its dwarf2loc.h declaration. */
21956 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
21958 struct comp_unit_head cu_header_local
;
21959 const struct comp_unit_head
*cu_headerp
;
21961 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
21963 if (cu_headerp
->version
== 2)
21964 return cu_headerp
->addr_size
;
21966 return cu_headerp
->offset_size
;
21969 /* Return the text offset of the CU. The returned offset comes from
21970 this CU's objfile. If this objfile came from a separate debuginfo
21971 file, then the offset may be different from the corresponding
21972 offset in the parent objfile. */
21975 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
21977 struct objfile
*objfile
= per_cu
->objfile
;
21979 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21982 /* Locate the .debug_info compilation unit from CU's objfile which contains
21983 the DIE at OFFSET. Raises an error on failure. */
21985 static struct dwarf2_per_cu_data
*
21986 dwarf2_find_containing_comp_unit (sect_offset offset
,
21987 unsigned int offset_in_dwz
,
21988 struct objfile
*objfile
)
21990 struct dwarf2_per_cu_data
*this_cu
;
21992 const sect_offset
*cu_off
;
21995 high
= dwarf2_per_objfile
->n_comp_units
- 1;
21998 struct dwarf2_per_cu_data
*mid_cu
;
21999 int mid
= low
+ (high
- low
) / 2;
22001 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
22002 cu_off
= &mid_cu
->offset
;
22003 if (mid_cu
->is_dwz
> offset_in_dwz
22004 || (mid_cu
->is_dwz
== offset_in_dwz
22005 && cu_off
->sect_off
>= offset
.sect_off
))
22010 gdb_assert (low
== high
);
22011 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
22012 cu_off
= &this_cu
->offset
;
22013 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
22015 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
22016 error (_("Dwarf Error: could not find partial DIE containing "
22017 "offset 0x%lx [in module %s]"),
22018 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
22020 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
22021 <= offset
.sect_off
);
22022 return dwarf2_per_objfile
->all_comp_units
[low
-1];
22026 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
22027 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
22028 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
22029 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
22030 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
22035 /* Initialize dwarf2_cu CU, owned by PER_CU. */
22038 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
22040 memset (cu
, 0, sizeof (*cu
));
22042 cu
->per_cu
= per_cu
;
22043 cu
->objfile
= per_cu
->objfile
;
22044 obstack_init (&cu
->comp_unit_obstack
);
22047 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
22050 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
22051 enum language pretend_language
)
22053 struct attribute
*attr
;
22055 /* Set the language we're debugging. */
22056 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
22058 set_cu_language (DW_UNSND (attr
), cu
);
22061 cu
->language
= pretend_language
;
22062 cu
->language_defn
= language_def (cu
->language
);
22065 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
22067 cu
->producer
= DW_STRING (attr
);
22070 /* Release one cached compilation unit, CU. We unlink it from the tree
22071 of compilation units, but we don't remove it from the read_in_chain;
22072 the caller is responsible for that.
22073 NOTE: DATA is a void * because this function is also used as a
22074 cleanup routine. */
22077 free_heap_comp_unit (void *data
)
22079 struct dwarf2_cu
*cu
= data
;
22081 gdb_assert (cu
->per_cu
!= NULL
);
22082 cu
->per_cu
->cu
= NULL
;
22085 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22090 /* This cleanup function is passed the address of a dwarf2_cu on the stack
22091 when we're finished with it. We can't free the pointer itself, but be
22092 sure to unlink it from the cache. Also release any associated storage. */
22095 free_stack_comp_unit (void *data
)
22097 struct dwarf2_cu
*cu
= data
;
22099 gdb_assert (cu
->per_cu
!= NULL
);
22100 cu
->per_cu
->cu
= NULL
;
22103 obstack_free (&cu
->comp_unit_obstack
, NULL
);
22104 cu
->partial_dies
= NULL
;
22107 /* Free all cached compilation units. */
22110 free_cached_comp_units (void *data
)
22112 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22114 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22115 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22116 while (per_cu
!= NULL
)
22118 struct dwarf2_per_cu_data
*next_cu
;
22120 next_cu
= per_cu
->cu
->read_in_chain
;
22122 free_heap_comp_unit (per_cu
->cu
);
22123 *last_chain
= next_cu
;
22129 /* Increase the age counter on each cached compilation unit, and free
22130 any that are too old. */
22133 age_cached_comp_units (void)
22135 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22137 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
22138 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22139 while (per_cu
!= NULL
)
22141 per_cu
->cu
->last_used
++;
22142 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
22143 dwarf2_mark (per_cu
->cu
);
22144 per_cu
= per_cu
->cu
->read_in_chain
;
22147 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22148 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22149 while (per_cu
!= NULL
)
22151 struct dwarf2_per_cu_data
*next_cu
;
22153 next_cu
= per_cu
->cu
->read_in_chain
;
22155 if (!per_cu
->cu
->mark
)
22157 free_heap_comp_unit (per_cu
->cu
);
22158 *last_chain
= next_cu
;
22161 last_chain
= &per_cu
->cu
->read_in_chain
;
22167 /* Remove a single compilation unit from the cache. */
22170 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
22172 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
22174 per_cu
= dwarf2_per_objfile
->read_in_chain
;
22175 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
22176 while (per_cu
!= NULL
)
22178 struct dwarf2_per_cu_data
*next_cu
;
22180 next_cu
= per_cu
->cu
->read_in_chain
;
22182 if (per_cu
== target_per_cu
)
22184 free_heap_comp_unit (per_cu
->cu
);
22186 *last_chain
= next_cu
;
22190 last_chain
= &per_cu
->cu
->read_in_chain
;
22196 /* Release all extra memory associated with OBJFILE. */
22199 dwarf2_free_objfile (struct objfile
*objfile
)
22201 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
22203 if (dwarf2_per_objfile
== NULL
)
22206 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
22207 free_cached_comp_units (NULL
);
22209 if (dwarf2_per_objfile
->quick_file_names_table
)
22210 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
22212 if (dwarf2_per_objfile
->line_header_hash
)
22213 htab_delete (dwarf2_per_objfile
->line_header_hash
);
22215 /* Everything else should be on the objfile obstack. */
22218 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
22219 We store these in a hash table separate from the DIEs, and preserve them
22220 when the DIEs are flushed out of cache.
22222 The CU "per_cu" pointer is needed because offset alone is not enough to
22223 uniquely identify the type. A file may have multiple .debug_types sections,
22224 or the type may come from a DWO file. Furthermore, while it's more logical
22225 to use per_cu->section+offset, with Fission the section with the data is in
22226 the DWO file but we don't know that section at the point we need it.
22227 We have to use something in dwarf2_per_cu_data (or the pointer to it)
22228 because we can enter the lookup routine, get_die_type_at_offset, from
22229 outside this file, and thus won't necessarily have PER_CU->cu.
22230 Fortunately, PER_CU is stable for the life of the objfile. */
22232 struct dwarf2_per_cu_offset_and_type
22234 const struct dwarf2_per_cu_data
*per_cu
;
22235 sect_offset offset
;
22239 /* Hash function for a dwarf2_per_cu_offset_and_type. */
22242 per_cu_offset_and_type_hash (const void *item
)
22244 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
22246 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
22249 /* Equality function for a dwarf2_per_cu_offset_and_type. */
22252 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
22254 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
22255 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
22257 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
22258 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
22261 /* Set the type associated with DIE to TYPE. Save it in CU's hash
22262 table if necessary. For convenience, return TYPE.
22264 The DIEs reading must have careful ordering to:
22265 * Not cause infite loops trying to read in DIEs as a prerequisite for
22266 reading current DIE.
22267 * Not trying to dereference contents of still incompletely read in types
22268 while reading in other DIEs.
22269 * Enable referencing still incompletely read in types just by a pointer to
22270 the type without accessing its fields.
22272 Therefore caller should follow these rules:
22273 * Try to fetch any prerequisite types we may need to build this DIE type
22274 before building the type and calling set_die_type.
22275 * After building type call set_die_type for current DIE as soon as
22276 possible before fetching more types to complete the current type.
22277 * Make the type as complete as possible before fetching more types. */
22279 static struct type
*
22280 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
22282 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
22283 struct objfile
*objfile
= cu
->objfile
;
22284 struct attribute
*attr
;
22285 struct dynamic_prop prop
;
22287 /* For Ada types, make sure that the gnat-specific data is always
22288 initialized (if not already set). There are a few types where
22289 we should not be doing so, because the type-specific area is
22290 already used to hold some other piece of info (eg: TYPE_CODE_FLT
22291 where the type-specific area is used to store the floatformat).
22292 But this is not a problem, because the gnat-specific information
22293 is actually not needed for these types. */
22294 if (need_gnat_info (cu
)
22295 && TYPE_CODE (type
) != TYPE_CODE_FUNC
22296 && TYPE_CODE (type
) != TYPE_CODE_FLT
22297 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
22298 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
22299 && TYPE_CODE (type
) != TYPE_CODE_METHOD
22300 && !HAVE_GNAT_AUX_INFO (type
))
22301 INIT_GNAT_SPECIFIC (type
);
22303 /* Read DW_AT_data_location and set in type. */
22304 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
22305 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
22306 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
, objfile
);
22308 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22310 dwarf2_per_objfile
->die_type_hash
=
22311 htab_create_alloc_ex (127,
22312 per_cu_offset_and_type_hash
,
22313 per_cu_offset_and_type_eq
,
22315 &objfile
->objfile_obstack
,
22316 hashtab_obstack_allocate
,
22317 dummy_obstack_deallocate
);
22320 ofs
.per_cu
= cu
->per_cu
;
22321 ofs
.offset
= die
->offset
;
22323 slot
= (struct dwarf2_per_cu_offset_and_type
**)
22324 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
22326 complaint (&symfile_complaints
,
22327 _("A problem internal to GDB: DIE 0x%x has type already set"),
22328 die
->offset
.sect_off
);
22329 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
22334 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
22335 or return NULL if the die does not have a saved type. */
22337 static struct type
*
22338 get_die_type_at_offset (sect_offset offset
,
22339 struct dwarf2_per_cu_data
*per_cu
)
22341 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
22343 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
22346 ofs
.per_cu
= per_cu
;
22347 ofs
.offset
= offset
;
22348 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
22355 /* Look up the type for DIE in CU in die_type_hash,
22356 or return NULL if DIE does not have a saved type. */
22358 static struct type
*
22359 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22361 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
22364 /* Add a dependence relationship from CU to REF_PER_CU. */
22367 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
22368 struct dwarf2_per_cu_data
*ref_per_cu
)
22372 if (cu
->dependencies
== NULL
)
22374 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
22375 NULL
, &cu
->comp_unit_obstack
,
22376 hashtab_obstack_allocate
,
22377 dummy_obstack_deallocate
);
22379 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
22381 *slot
= ref_per_cu
;
22384 /* Subroutine of dwarf2_mark to pass to htab_traverse.
22385 Set the mark field in every compilation unit in the
22386 cache that we must keep because we are keeping CU. */
22389 dwarf2_mark_helper (void **slot
, void *data
)
22391 struct dwarf2_per_cu_data
*per_cu
;
22393 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
22395 /* cu->dependencies references may not yet have been ever read if QUIT aborts
22396 reading of the chain. As such dependencies remain valid it is not much
22397 useful to track and undo them during QUIT cleanups. */
22398 if (per_cu
->cu
== NULL
)
22401 if (per_cu
->cu
->mark
)
22403 per_cu
->cu
->mark
= 1;
22405 if (per_cu
->cu
->dependencies
!= NULL
)
22406 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22411 /* Set the mark field in CU and in every other compilation unit in the
22412 cache that we must keep because we are keeping CU. */
22415 dwarf2_mark (struct dwarf2_cu
*cu
)
22420 if (cu
->dependencies
!= NULL
)
22421 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
22425 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
22429 per_cu
->cu
->mark
= 0;
22430 per_cu
= per_cu
->cu
->read_in_chain
;
22434 /* Trivial hash function for partial_die_info: the hash value of a DIE
22435 is its offset in .debug_info for this objfile. */
22438 partial_die_hash (const void *item
)
22440 const struct partial_die_info
*part_die
= item
;
22442 return part_die
->offset
.sect_off
;
22445 /* Trivial comparison function for partial_die_info structures: two DIEs
22446 are equal if they have the same offset. */
22449 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
22451 const struct partial_die_info
*part_die_lhs
= item_lhs
;
22452 const struct partial_die_info
*part_die_rhs
= item_rhs
;
22454 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
22457 static struct cmd_list_element
*set_dwarf_cmdlist
;
22458 static struct cmd_list_element
*show_dwarf_cmdlist
;
22461 set_dwarf_cmd (char *args
, int from_tty
)
22463 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
22468 show_dwarf_cmd (char *args
, int from_tty
)
22470 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
22473 /* Free data associated with OBJFILE, if necessary. */
22476 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
22478 struct dwarf2_per_objfile
*data
= d
;
22481 /* Make sure we don't accidentally use dwarf2_per_objfile while
22483 dwarf2_per_objfile
= NULL
;
22485 for (ix
= 0; ix
< data
->n_comp_units
; ++ix
)
22486 VEC_free (dwarf2_per_cu_ptr
, data
->all_comp_units
[ix
]->imported_symtabs
);
22488 for (ix
= 0; ix
< data
->n_type_units
; ++ix
)
22489 VEC_free (dwarf2_per_cu_ptr
,
22490 data
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
22491 xfree (data
->all_type_units
);
22493 VEC_free (dwarf2_section_info_def
, data
->types
);
22495 if (data
->dwo_files
)
22496 free_dwo_files (data
->dwo_files
, objfile
);
22497 if (data
->dwp_file
)
22498 gdb_bfd_unref (data
->dwp_file
->dbfd
);
22500 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
22501 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
22505 /* The "save gdb-index" command. */
22507 /* The contents of the hash table we create when building the string
22509 struct strtab_entry
22511 offset_type offset
;
22515 /* Hash function for a strtab_entry.
22517 Function is used only during write_hash_table so no index format backward
22518 compatibility is needed. */
22521 hash_strtab_entry (const void *e
)
22523 const struct strtab_entry
*entry
= e
;
22524 return mapped_index_string_hash (INT_MAX
, entry
->str
);
22527 /* Equality function for a strtab_entry. */
22530 eq_strtab_entry (const void *a
, const void *b
)
22532 const struct strtab_entry
*ea
= a
;
22533 const struct strtab_entry
*eb
= b
;
22534 return !strcmp (ea
->str
, eb
->str
);
22537 /* Create a strtab_entry hash table. */
22540 create_strtab (void)
22542 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
22543 xfree
, xcalloc
, xfree
);
22546 /* Add a string to the constant pool. Return the string's offset in
22550 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
22553 struct strtab_entry entry
;
22554 struct strtab_entry
*result
;
22557 slot
= htab_find_slot (table
, &entry
, INSERT
);
22562 result
= XNEW (struct strtab_entry
);
22563 result
->offset
= obstack_object_size (cpool
);
22565 obstack_grow_str0 (cpool
, str
);
22568 return result
->offset
;
22571 /* An entry in the symbol table. */
22572 struct symtab_index_entry
22574 /* The name of the symbol. */
22576 /* The offset of the name in the constant pool. */
22577 offset_type index_offset
;
22578 /* A sorted vector of the indices of all the CUs that hold an object
22580 VEC (offset_type
) *cu_indices
;
22583 /* The symbol table. This is a power-of-2-sized hash table. */
22584 struct mapped_symtab
22586 offset_type n_elements
;
22588 struct symtab_index_entry
**data
;
22591 /* Hash function for a symtab_index_entry. */
22594 hash_symtab_entry (const void *e
)
22596 const struct symtab_index_entry
*entry
= e
;
22597 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
22598 sizeof (offset_type
) * VEC_length (offset_type
,
22599 entry
->cu_indices
),
22603 /* Equality function for a symtab_index_entry. */
22606 eq_symtab_entry (const void *a
, const void *b
)
22608 const struct symtab_index_entry
*ea
= a
;
22609 const struct symtab_index_entry
*eb
= b
;
22610 int len
= VEC_length (offset_type
, ea
->cu_indices
);
22611 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
22613 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
22614 VEC_address (offset_type
, eb
->cu_indices
),
22615 sizeof (offset_type
) * len
);
22618 /* Destroy a symtab_index_entry. */
22621 delete_symtab_entry (void *p
)
22623 struct symtab_index_entry
*entry
= p
;
22624 VEC_free (offset_type
, entry
->cu_indices
);
22628 /* Create a hash table holding symtab_index_entry objects. */
22631 create_symbol_hash_table (void)
22633 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
22634 delete_symtab_entry
, xcalloc
, xfree
);
22637 /* Create a new mapped symtab object. */
22639 static struct mapped_symtab
*
22640 create_mapped_symtab (void)
22642 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
22643 symtab
->n_elements
= 0;
22644 symtab
->size
= 1024;
22645 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22649 /* Destroy a mapped_symtab. */
22652 cleanup_mapped_symtab (void *p
)
22654 struct mapped_symtab
*symtab
= p
;
22655 /* The contents of the array are freed when the other hash table is
22657 xfree (symtab
->data
);
22661 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22664 Function is used only during write_hash_table so no index format backward
22665 compatibility is needed. */
22667 static struct symtab_index_entry
**
22668 find_slot (struct mapped_symtab
*symtab
, const char *name
)
22670 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
22672 index
= hash
& (symtab
->size
- 1);
22673 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
22677 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
22678 return &symtab
->data
[index
];
22679 index
= (index
+ step
) & (symtab
->size
- 1);
22683 /* Expand SYMTAB's hash table. */
22686 hash_expand (struct mapped_symtab
*symtab
)
22688 offset_type old_size
= symtab
->size
;
22690 struct symtab_index_entry
**old_entries
= symtab
->data
;
22693 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
22695 for (i
= 0; i
< old_size
; ++i
)
22697 if (old_entries
[i
])
22699 struct symtab_index_entry
**slot
= find_slot (symtab
,
22700 old_entries
[i
]->name
);
22701 *slot
= old_entries
[i
];
22705 xfree (old_entries
);
22708 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22709 CU_INDEX is the index of the CU in which the symbol appears.
22710 IS_STATIC is one if the symbol is static, otherwise zero (global). */
22713 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
22714 int is_static
, gdb_index_symbol_kind kind
,
22715 offset_type cu_index
)
22717 struct symtab_index_entry
**slot
;
22718 offset_type cu_index_and_attrs
;
22720 ++symtab
->n_elements
;
22721 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
22722 hash_expand (symtab
);
22724 slot
= find_slot (symtab
, name
);
22727 *slot
= XNEW (struct symtab_index_entry
);
22728 (*slot
)->name
= name
;
22729 /* index_offset is set later. */
22730 (*slot
)->cu_indices
= NULL
;
22733 cu_index_and_attrs
= 0;
22734 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
22735 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
22736 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
22738 /* We don't want to record an index value twice as we want to avoid the
22740 We process all global symbols and then all static symbols
22741 (which would allow us to avoid the duplication by only having to check
22742 the last entry pushed), but a symbol could have multiple kinds in one CU.
22743 To keep things simple we don't worry about the duplication here and
22744 sort and uniqufy the list after we've processed all symbols. */
22745 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
22748 /* qsort helper routine for uniquify_cu_indices. */
22751 offset_type_compare (const void *ap
, const void *bp
)
22753 offset_type a
= *(offset_type
*) ap
;
22754 offset_type b
= *(offset_type
*) bp
;
22756 return (a
> b
) - (b
> a
);
22759 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22762 uniquify_cu_indices (struct mapped_symtab
*symtab
)
22766 for (i
= 0; i
< symtab
->size
; ++i
)
22768 struct symtab_index_entry
*entry
= symtab
->data
[i
];
22771 && entry
->cu_indices
!= NULL
)
22773 unsigned int next_to_insert
, next_to_check
;
22774 offset_type last_value
;
22776 qsort (VEC_address (offset_type
, entry
->cu_indices
),
22777 VEC_length (offset_type
, entry
->cu_indices
),
22778 sizeof (offset_type
), offset_type_compare
);
22780 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
22781 next_to_insert
= 1;
22782 for (next_to_check
= 1;
22783 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
22786 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
22789 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
22791 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
22796 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
22801 /* Add a vector of indices to the constant pool. */
22804 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
22805 struct symtab_index_entry
*entry
)
22809 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
22812 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
22813 offset_type val
= MAYBE_SWAP (len
);
22818 entry
->index_offset
= obstack_object_size (cpool
);
22820 obstack_grow (cpool
, &val
, sizeof (val
));
22822 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
22825 val
= MAYBE_SWAP (iter
);
22826 obstack_grow (cpool
, &val
, sizeof (val
));
22831 struct symtab_index_entry
*old_entry
= *slot
;
22832 entry
->index_offset
= old_entry
->index_offset
;
22835 return entry
->index_offset
;
22838 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22839 constant pool entries going into the obstack CPOOL. */
22842 write_hash_table (struct mapped_symtab
*symtab
,
22843 struct obstack
*output
, struct obstack
*cpool
)
22846 htab_t symbol_hash_table
;
22849 symbol_hash_table
= create_symbol_hash_table ();
22850 str_table
= create_strtab ();
22852 /* We add all the index vectors to the constant pool first, to
22853 ensure alignment is ok. */
22854 for (i
= 0; i
< symtab
->size
; ++i
)
22856 if (symtab
->data
[i
])
22857 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
22860 /* Now write out the hash table. */
22861 for (i
= 0; i
< symtab
->size
; ++i
)
22863 offset_type str_off
, vec_off
;
22865 if (symtab
->data
[i
])
22867 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
22868 vec_off
= symtab
->data
[i
]->index_offset
;
22872 /* While 0 is a valid constant pool index, it is not valid
22873 to have 0 for both offsets. */
22878 str_off
= MAYBE_SWAP (str_off
);
22879 vec_off
= MAYBE_SWAP (vec_off
);
22881 obstack_grow (output
, &str_off
, sizeof (str_off
));
22882 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
22885 htab_delete (str_table
);
22886 htab_delete (symbol_hash_table
);
22889 /* Struct to map psymtab to CU index in the index file. */
22890 struct psymtab_cu_index_map
22892 struct partial_symtab
*psymtab
;
22893 unsigned int cu_index
;
22897 hash_psymtab_cu_index (const void *item
)
22899 const struct psymtab_cu_index_map
*map
= item
;
22901 return htab_hash_pointer (map
->psymtab
);
22905 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
22907 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
22908 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
22910 return lhs
->psymtab
== rhs
->psymtab
;
22913 /* Helper struct for building the address table. */
22914 struct addrmap_index_data
22916 struct objfile
*objfile
;
22917 struct obstack
*addr_obstack
;
22918 htab_t cu_index_htab
;
22920 /* Non-zero if the previous_* fields are valid.
22921 We can't write an entry until we see the next entry (since it is only then
22922 that we know the end of the entry). */
22923 int previous_valid
;
22924 /* Index of the CU in the table of all CUs in the index file. */
22925 unsigned int previous_cu_index
;
22926 /* Start address of the CU. */
22927 CORE_ADDR previous_cu_start
;
22930 /* Write an address entry to OBSTACK. */
22933 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
22934 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
22936 offset_type cu_index_to_write
;
22938 CORE_ADDR baseaddr
;
22940 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
22942 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
22943 obstack_grow (obstack
, addr
, 8);
22944 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
22945 obstack_grow (obstack
, addr
, 8);
22946 cu_index_to_write
= MAYBE_SWAP (cu_index
);
22947 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
22950 /* Worker function for traversing an addrmap to build the address table. */
22953 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
22955 struct addrmap_index_data
*data
= datap
;
22956 struct partial_symtab
*pst
= obj
;
22958 if (data
->previous_valid
)
22959 add_address_entry (data
->objfile
, data
->addr_obstack
,
22960 data
->previous_cu_start
, start_addr
,
22961 data
->previous_cu_index
);
22963 data
->previous_cu_start
= start_addr
;
22966 struct psymtab_cu_index_map find_map
, *map
;
22967 find_map
.psymtab
= pst
;
22968 map
= htab_find (data
->cu_index_htab
, &find_map
);
22969 gdb_assert (map
!= NULL
);
22970 data
->previous_cu_index
= map
->cu_index
;
22971 data
->previous_valid
= 1;
22974 data
->previous_valid
= 0;
22979 /* Write OBJFILE's address map to OBSTACK.
22980 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22981 in the index file. */
22984 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
22985 htab_t cu_index_htab
)
22987 struct addrmap_index_data addrmap_index_data
;
22989 /* When writing the address table, we have to cope with the fact that
22990 the addrmap iterator only provides the start of a region; we have to
22991 wait until the next invocation to get the start of the next region. */
22993 addrmap_index_data
.objfile
= objfile
;
22994 addrmap_index_data
.addr_obstack
= obstack
;
22995 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
22996 addrmap_index_data
.previous_valid
= 0;
22998 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
22999 &addrmap_index_data
);
23001 /* It's highly unlikely the last entry (end address = 0xff...ff)
23002 is valid, but we should still handle it.
23003 The end address is recorded as the start of the next region, but that
23004 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
23006 if (addrmap_index_data
.previous_valid
)
23007 add_address_entry (objfile
, obstack
,
23008 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
23009 addrmap_index_data
.previous_cu_index
);
23012 /* Return the symbol kind of PSYM. */
23014 static gdb_index_symbol_kind
23015 symbol_kind (struct partial_symbol
*psym
)
23017 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
23018 enum address_class aclass
= PSYMBOL_CLASS (psym
);
23026 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
23028 return GDB_INDEX_SYMBOL_KIND_TYPE
;
23030 case LOC_CONST_BYTES
:
23031 case LOC_OPTIMIZED_OUT
:
23033 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
23035 /* Note: It's currently impossible to recognize psyms as enum values
23036 short of reading the type info. For now punt. */
23037 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
23039 /* There are other LOC_FOO values that one might want to classify
23040 as variables, but dwarf2read.c doesn't currently use them. */
23041 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23043 case STRUCT_DOMAIN
:
23044 return GDB_INDEX_SYMBOL_KIND_TYPE
;
23046 return GDB_INDEX_SYMBOL_KIND_OTHER
;
23050 /* Add a list of partial symbols to SYMTAB. */
23053 write_psymbols (struct mapped_symtab
*symtab
,
23055 struct partial_symbol
**psymp
,
23057 offset_type cu_index
,
23060 for (; count
-- > 0; ++psymp
)
23062 struct partial_symbol
*psym
= *psymp
;
23065 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
23066 error (_("Ada is not currently supported by the index"));
23068 /* Only add a given psymbol once. */
23069 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
23072 gdb_index_symbol_kind kind
= symbol_kind (psym
);
23075 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
23076 is_static
, kind
, cu_index
);
23081 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
23082 exception if there is an error. */
23085 write_obstack (FILE *file
, struct obstack
*obstack
)
23087 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
23089 != obstack_object_size (obstack
))
23090 error (_("couldn't data write to file"));
23093 /* Unlink a file if the argument is not NULL. */
23096 unlink_if_set (void *p
)
23098 char **filename
= p
;
23100 unlink (*filename
);
23103 /* A helper struct used when iterating over debug_types. */
23104 struct signatured_type_index_data
23106 struct objfile
*objfile
;
23107 struct mapped_symtab
*symtab
;
23108 struct obstack
*types_list
;
23113 /* A helper function that writes a single signatured_type to an
23117 write_one_signatured_type (void **slot
, void *d
)
23119 struct signatured_type_index_data
*info
= d
;
23120 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
23121 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
23124 write_psymbols (info
->symtab
,
23126 info
->objfile
->global_psymbols
.list
23127 + psymtab
->globals_offset
,
23128 psymtab
->n_global_syms
, info
->cu_index
,
23130 write_psymbols (info
->symtab
,
23132 info
->objfile
->static_psymbols
.list
23133 + psymtab
->statics_offset
,
23134 psymtab
->n_static_syms
, info
->cu_index
,
23137 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23138 entry
->per_cu
.offset
.sect_off
);
23139 obstack_grow (info
->types_list
, val
, 8);
23140 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23141 entry
->type_offset_in_tu
.cu_off
);
23142 obstack_grow (info
->types_list
, val
, 8);
23143 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
23144 obstack_grow (info
->types_list
, val
, 8);
23151 /* Recurse into all "included" dependencies and write their symbols as
23152 if they appeared in this psymtab. */
23155 recursively_write_psymbols (struct objfile
*objfile
,
23156 struct partial_symtab
*psymtab
,
23157 struct mapped_symtab
*symtab
,
23159 offset_type cu_index
)
23163 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
23164 if (psymtab
->dependencies
[i
]->user
!= NULL
)
23165 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
23166 symtab
, psyms_seen
, cu_index
);
23168 write_psymbols (symtab
,
23170 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
23171 psymtab
->n_global_syms
, cu_index
,
23173 write_psymbols (symtab
,
23175 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
23176 psymtab
->n_static_syms
, cu_index
,
23180 /* Create an index file for OBJFILE in the directory DIR. */
23183 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
23185 struct cleanup
*cleanup
;
23186 char *filename
, *cleanup_filename
;
23187 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
23188 struct obstack cu_list
, types_cu_list
;
23191 struct mapped_symtab
*symtab
;
23192 offset_type val
, size_of_contents
, total_len
;
23195 htab_t cu_index_htab
;
23196 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
23198 if (dwarf2_per_objfile
->using_index
)
23199 error (_("Cannot use an index to create the index"));
23201 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
23202 error (_("Cannot make an index when the file has multiple .debug_types sections"));
23204 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
23207 if (stat (objfile_name (objfile
), &st
) < 0)
23208 perror_with_name (objfile_name (objfile
));
23210 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile_name (objfile
)),
23211 INDEX_SUFFIX
, (char *) NULL
);
23212 cleanup
= make_cleanup (xfree
, filename
);
23214 out_file
= gdb_fopen_cloexec (filename
, "wb");
23216 error (_("Can't open `%s' for writing"), filename
);
23218 cleanup_filename
= filename
;
23219 make_cleanup (unlink_if_set
, &cleanup_filename
);
23221 symtab
= create_mapped_symtab ();
23222 make_cleanup (cleanup_mapped_symtab
, symtab
);
23224 obstack_init (&addr_obstack
);
23225 make_cleanup_obstack_free (&addr_obstack
);
23227 obstack_init (&cu_list
);
23228 make_cleanup_obstack_free (&cu_list
);
23230 obstack_init (&types_cu_list
);
23231 make_cleanup_obstack_free (&types_cu_list
);
23233 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
23234 NULL
, xcalloc
, xfree
);
23235 make_cleanup_htab_delete (psyms_seen
);
23237 /* While we're scanning CU's create a table that maps a psymtab pointer
23238 (which is what addrmap records) to its index (which is what is recorded
23239 in the index file). This will later be needed to write the address
23241 cu_index_htab
= htab_create_alloc (100,
23242 hash_psymtab_cu_index
,
23243 eq_psymtab_cu_index
,
23244 NULL
, xcalloc
, xfree
);
23245 make_cleanup_htab_delete (cu_index_htab
);
23246 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
23247 xmalloc (sizeof (struct psymtab_cu_index_map
)
23248 * dwarf2_per_objfile
->n_comp_units
);
23249 make_cleanup (xfree
, psymtab_cu_index_map
);
23251 /* The CU list is already sorted, so we don't need to do additional
23252 work here. Also, the debug_types entries do not appear in
23253 all_comp_units, but only in their own hash table. */
23254 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
23256 struct dwarf2_per_cu_data
*per_cu
23257 = dwarf2_per_objfile
->all_comp_units
[i
];
23258 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
23260 struct psymtab_cu_index_map
*map
;
23263 /* CU of a shared file from 'dwz -m' may be unused by this main file.
23264 It may be referenced from a local scope but in such case it does not
23265 need to be present in .gdb_index. */
23266 if (psymtab
== NULL
)
23269 if (psymtab
->user
== NULL
)
23270 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
23272 map
= &psymtab_cu_index_map
[i
];
23273 map
->psymtab
= psymtab
;
23275 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
23276 gdb_assert (slot
!= NULL
);
23277 gdb_assert (*slot
== NULL
);
23280 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
23281 per_cu
->offset
.sect_off
);
23282 obstack_grow (&cu_list
, val
, 8);
23283 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
23284 obstack_grow (&cu_list
, val
, 8);
23287 /* Dump the address map. */
23288 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
23290 /* Write out the .debug_type entries, if any. */
23291 if (dwarf2_per_objfile
->signatured_types
)
23293 struct signatured_type_index_data sig_data
;
23295 sig_data
.objfile
= objfile
;
23296 sig_data
.symtab
= symtab
;
23297 sig_data
.types_list
= &types_cu_list
;
23298 sig_data
.psyms_seen
= psyms_seen
;
23299 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
23300 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
23301 write_one_signatured_type
, &sig_data
);
23304 /* Now that we've processed all symbols we can shrink their cu_indices
23306 uniquify_cu_indices (symtab
);
23308 obstack_init (&constant_pool
);
23309 make_cleanup_obstack_free (&constant_pool
);
23310 obstack_init (&symtab_obstack
);
23311 make_cleanup_obstack_free (&symtab_obstack
);
23312 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
23314 obstack_init (&contents
);
23315 make_cleanup_obstack_free (&contents
);
23316 size_of_contents
= 6 * sizeof (offset_type
);
23317 total_len
= size_of_contents
;
23319 /* The version number. */
23320 val
= MAYBE_SWAP (8);
23321 obstack_grow (&contents
, &val
, sizeof (val
));
23323 /* The offset of the CU list from the start of the file. */
23324 val
= MAYBE_SWAP (total_len
);
23325 obstack_grow (&contents
, &val
, sizeof (val
));
23326 total_len
+= obstack_object_size (&cu_list
);
23328 /* The offset of the types CU list from the start of the file. */
23329 val
= MAYBE_SWAP (total_len
);
23330 obstack_grow (&contents
, &val
, sizeof (val
));
23331 total_len
+= obstack_object_size (&types_cu_list
);
23333 /* The offset of the address table from the start of the file. */
23334 val
= MAYBE_SWAP (total_len
);
23335 obstack_grow (&contents
, &val
, sizeof (val
));
23336 total_len
+= obstack_object_size (&addr_obstack
);
23338 /* The offset of the symbol table from the start of the file. */
23339 val
= MAYBE_SWAP (total_len
);
23340 obstack_grow (&contents
, &val
, sizeof (val
));
23341 total_len
+= obstack_object_size (&symtab_obstack
);
23343 /* The offset of the constant pool from the start of the file. */
23344 val
= MAYBE_SWAP (total_len
);
23345 obstack_grow (&contents
, &val
, sizeof (val
));
23346 total_len
+= obstack_object_size (&constant_pool
);
23348 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
23350 write_obstack (out_file
, &contents
);
23351 write_obstack (out_file
, &cu_list
);
23352 write_obstack (out_file
, &types_cu_list
);
23353 write_obstack (out_file
, &addr_obstack
);
23354 write_obstack (out_file
, &symtab_obstack
);
23355 write_obstack (out_file
, &constant_pool
);
23359 /* We want to keep the file, so we set cleanup_filename to NULL
23360 here. See unlink_if_set. */
23361 cleanup_filename
= NULL
;
23363 do_cleanups (cleanup
);
23366 /* Implementation of the `save gdb-index' command.
23368 Note that the file format used by this command is documented in the
23369 GDB manual. Any changes here must be documented there. */
23372 save_gdb_index_command (char *arg
, int from_tty
)
23374 struct objfile
*objfile
;
23377 error (_("usage: save gdb-index DIRECTORY"));
23379 ALL_OBJFILES (objfile
)
23383 /* If the objfile does not correspond to an actual file, skip it. */
23384 if (stat (objfile_name (objfile
), &st
) < 0)
23387 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
23388 if (dwarf2_per_objfile
)
23393 write_psymtabs_to_index (objfile
, arg
);
23395 CATCH (except
, RETURN_MASK_ERROR
)
23397 exception_fprintf (gdb_stderr
, except
,
23398 _("Error while writing index for `%s': "),
23399 objfile_name (objfile
));
23408 int dwarf_always_disassemble
;
23411 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
23412 struct cmd_list_element
*c
, const char *value
)
23414 fprintf_filtered (file
,
23415 _("Whether to always disassemble "
23416 "DWARF expressions is %s.\n"),
23421 show_check_physname (struct ui_file
*file
, int from_tty
,
23422 struct cmd_list_element
*c
, const char *value
)
23424 fprintf_filtered (file
,
23425 _("Whether to check \"physname\" is %s.\n"),
23429 void _initialize_dwarf2_read (void);
23432 _initialize_dwarf2_read (void)
23434 struct cmd_list_element
*c
;
23436 dwarf2_objfile_data_key
23437 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
23439 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
23440 Set DWARF specific variables.\n\
23441 Configure DWARF variables such as the cache size"),
23442 &set_dwarf_cmdlist
, "maintenance set dwarf ",
23443 0/*allow-unknown*/, &maintenance_set_cmdlist
);
23445 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
23446 Show DWARF specific variables\n\
23447 Show DWARF variables such as the cache size"),
23448 &show_dwarf_cmdlist
, "maintenance show dwarf ",
23449 0/*allow-unknown*/, &maintenance_show_cmdlist
);
23451 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
23452 &dwarf_max_cache_age
, _("\
23453 Set the upper bound on the age of cached DWARF compilation units."), _("\
23454 Show the upper bound on the age of cached DWARF compilation units."), _("\
23455 A higher limit means that cached compilation units will be stored\n\
23456 in memory longer, and more total memory will be used. Zero disables\n\
23457 caching, which can slow down startup."),
23459 show_dwarf_max_cache_age
,
23460 &set_dwarf_cmdlist
,
23461 &show_dwarf_cmdlist
);
23463 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
23464 &dwarf_always_disassemble
, _("\
23465 Set whether `info address' always disassembles DWARF expressions."), _("\
23466 Show whether `info address' always disassembles DWARF expressions."), _("\
23467 When enabled, DWARF expressions are always printed in an assembly-like\n\
23468 syntax. When disabled, expressions will be printed in a more\n\
23469 conversational style, when possible."),
23471 show_dwarf_always_disassemble
,
23472 &set_dwarf_cmdlist
,
23473 &show_dwarf_cmdlist
);
23475 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
23476 Set debugging of the DWARF reader."), _("\
23477 Show debugging of the DWARF reader."), _("\
23478 When enabled (non-zero), debugging messages are printed during DWARF\n\
23479 reading and symtab expansion. A value of 1 (one) provides basic\n\
23480 information. A value greater than 1 provides more verbose information."),
23483 &setdebuglist
, &showdebuglist
);
23485 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
23486 Set debugging of the DWARF DIE reader."), _("\
23487 Show debugging of the DWARF DIE reader."), _("\
23488 When enabled (non-zero), DIEs are dumped after they are read in.\n\
23489 The value is the maximum depth to print."),
23492 &setdebuglist
, &showdebuglist
);
23494 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
23495 Set debugging of the dwarf line reader."), _("\
23496 Show debugging of the dwarf line reader."), _("\
23497 When enabled (non-zero), line number entries are dumped as they are read in.\n\
23498 A value of 1 (one) provides basic information.\n\
23499 A value greater than 1 provides more verbose information."),
23502 &setdebuglist
, &showdebuglist
);
23504 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
23505 Set cross-checking of \"physname\" code against demangler."), _("\
23506 Show cross-checking of \"physname\" code against demangler."), _("\
23507 When enabled, GDB's internal \"physname\" code is checked against\n\
23509 NULL
, show_check_physname
,
23510 &setdebuglist
, &showdebuglist
);
23512 add_setshow_boolean_cmd ("use-deprecated-index-sections",
23513 no_class
, &use_deprecated_index_sections
, _("\
23514 Set whether to use deprecated gdb_index sections."), _("\
23515 Show whether to use deprecated gdb_index sections."), _("\
23516 When enabled, deprecated .gdb_index sections are used anyway.\n\
23517 Normally they are ignored either because of a missing feature or\n\
23518 performance issue.\n\
23519 Warning: This option must be enabled before gdb reads the file."),
23522 &setlist
, &showlist
);
23524 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
23526 Save a gdb-index file.\n\
23527 Usage: save gdb-index DIRECTORY"),
23529 set_cmd_completer (c
, filename_completer
);
23531 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23532 &dwarf2_locexpr_funcs
);
23533 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
23534 &dwarf2_loclist_funcs
);
23536 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23537 &dwarf2_block_frame_base_locexpr_funcs
);
23538 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
23539 &dwarf2_block_frame_base_loclist_funcs
);